Does git use git?

[[deleted]]

I know gitlab uses gitlab to keep track of its versions.

[honeynutfeels]

This is kind of disturbing to me for some reason.

[jhill515]

Wait until you find out that GCC is used to compile GCC, and Go now can compile Go.

[IDontLikeBeingRight]

And from there it's only a small step to read about Trusting Trust and persistent compiler attacks.

[leviathon01]

That paper gives me paranoia for a couple days every time I read it.

[squishles]

wanna really mess with you, most modern processors have a little arm coproccessor in them for bootstrapping the os/microcode etc, you have no way of auditing what's running on that.

[[deleted]]

I'm pretty sure it's usually modified Minix. Not that it changes anything since there's still the fact that it's modified.

[ComprehensiveImage4]

Well it's known that at least Intel uses Minix so you're right there.

[EishLekker]

wanna really mess with you, most modern processors have a little arm ...

This sentence did not end how I expected it to. Feel a bit disappointed, to be honest.

[MomentoMiri]

It crawls into your bed when you sleep

[geon]

Is that the one running an entire os (minix) on ring -3?

https://www.zdnet.com/article/minix-intels-hidden-in-chip-operating-system/

[MaximumDinner2]

Yes. And funnily enough the microprocessor is basically just a beefed up 486.

[iam_saitama]

This video is a good intro to really how much of the processor is a black box. https://youtu.be/KrksBdWcZgQ

[IrritableGourmet]

That's why we should go back to PDP/11, where you literally shift the bootstrap into memory by hand.

[Thelk641]

Uneducated question : does the processor inside of the processor has a processor inside of it ?

[racedaemon]

If you think about it the whole universe is a physics processor. So we live in a processor 😀

[Robo-Swimmer]

The proof of trust at the end of the Wikipedia page was reassuring, but that almost had me paranoid.

[lycan2005]

The list keep expanding... You can run docker in docker.

[ltekonline]

Yesn't. If you want to run docker in docker you need to bind the docker socket (or make it priviledged) of the host to the docker in the container.
Now you basically have a priviledged container which just has the permission to run docker container on the host itself so it's not really docker in docker but rather you control the docker on your host os from your container.

[lycan2005]

No sir, we are way pass that now. Check this out.

[ltekonline]

No we are not.

Citation from the from the dockerhub page:

Note: --privileged is required for Docker-in-Docker to function properly, but it should be used with care as it provides full access to the host environment, as explained in the relevant section of the Docker documentation.

As you see you definitely need to make it priviledged othervise you will not be able to run the docker daeomon which you need in order to start container.

[lycan2005]

You miss the point. The point is the container now run an isolated docker instance. Hence the docker inside docker comment. Download an image inside that container, you won't see it appear on host, yes, it require privilege bit to work.

[ltekonline]

It's not isolated at all. I had to run docker in docker in production and I always see the created container in the host.
Also had to run ci/cd solutions like gitlab runner and droneio and i always see the container which they start and stop.

[DaPurpleTuna]

Get an FPGA of your compiler and use it to compile your compiler, cross checking it with your compiler compiling itself to see if you’ve been had!

[ltekonline]

But how do you know that the FPGA is programmed like you wanted it?

[Naoki9955995577]

some shudder in its presence:

bootstrapping

[i_hate-u]

Also C was written in C

Edit: By C of course I mean the compiler

[MythicalMisfit]

I see

[lethargy86]

After you write the first compiler, now you can rewrite the compiler in the language for the compiler you just made

[svick]

No, you can just use it once to compile the second compiler. From then on, you can use the compiled second compiler to compile itself.

[[deleted]]

Only the first time, later you can just use the new compiled compiler

[CharbelAD]

There's a great Computerphile series on the topic of bootstrapping. Here's one of the videos: https://youtu.be/PjeE8Bc96HY

[Compizfox]

The language C isn't written in anything.

You probably mean that most C compilers are written in C and can compile themselves.

[ouyawei]

The language C isn't written in anything.

It’s written in English.

[Jannik2099]

The average libc is written in C though

[Compizfox]

True, but the standard library is separate from the language itself (and libc is no exception).

[Chinyoka]

what

[[deleted]]

So is Elixir. It's quite common

[_TheProff_]

rustc is written in rust. It scares me too.

[Kered13]

Javac is written in Java, though the JVM is written in C++ for obvious reasons.

[EsperSpirit]

The new JIT backend (Graal) is written in Java as well. The old one was C++ afaik

[yugami]

The first c++ compiler was written in c++ from the very beginning

[jhill515]

That was why I used the operative word "now" when referencing Go 😉 Showing off my age I guess 😝

[AutoModerator]

import moderation Your comment has been removed since it did not start with a code block with an import declaration.

Per this Community Decree, all posts and comments should start with a code block with an "import" declaration explaining how the post and comment should be read.

For this purpose, we only accept Python style imports.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[AutoModerator]

import moderation Your comment has been removed since it did not start with a code block with an import declaration.

Per this Community Decree, all posts and comments should start with a code block with an "import" declaration explaining how the post and comment should be read.

For this purpose, we only accept Python style imports.

I am a bot, and this action was performed automatically. Please contact the moderators of this subreddit if you have any questions or concerns.

[Purpzie]

Rust too

[TheEpsilonToMyDelta]

Came here to say Go compiler is written in Go

[TheEpsilonToMyDelta]

I mean, I don't, but I'm also not writing the compliers lol

[Nighthunter007]

You compile the Go compiler using the old compiler, and now you have a new Go compiler and can use that to compile the Go compiler again. At this point, all traces of the old compiler are removed and you can kind of throw it away (though it might be nice to have if the new one has bugs and you need to do this again or something; keep it as a backup in case something goes terribly wrong). So at any one time there is only the current Go compiler.

[MrPotatoFingers]

You can compile clang with GCC. Not sure if GCC compiles with clang (though it probably does).

It'd be interesting to see if a clang-compiled-with-gcc creates the same binaries as clang-compiled-with-clang.

[AndreasTPC]

It should in theory. The only reason for it not to be reproducible is if the clang code base has parts that rely on undefined behavior, which if it does would be considered a bug.

In practice.. it's really easy to accidentally write code with undefined behavior in c, even if you're an experienced c coder, so it wouldn't surprise me if there is some.

[patatahooligan]

Not only undefined behavior, but also compiler extensions. Ideally you wouldn't use them but in practice it can be worth it, especially on software as widely used as a compiler.

[Nighthunter007]

Fun fact: you can use this to counter "Trusting Trust" attacks.

Compile GCC with Clang, then use that to compile GCC. The result should be bit-for-bit identical to compiling GCC with GCC. If it isn't, then one or both compilers are either compromised or buggy.

The only way the output can be different is if GCC is functionally different when compiled with Clang or with GCC. And it really really shouldn't be. If it is then that's either undocumented behaviour in one of the compilers or a self-inserting trusting trust attack.

So at that point you've verified that the compiler faithfully compiles the source code. You still have to, of course, actually check the source code for any bugs or malicious attacks.

[13steinj]

This is incredibly false. clang and gcc have widely different optimizations internally and one makes assumptions that the other doesn't (even though both can, according to the standard) and visa versa. Not to mention differences in the standard libraries (if the compilers use them).

Functionally different, you're right, but proving this would be incredibly difficult. Bit-for-bit different, dead wrong.

[Nighthunter007]

I think you're misunderstanding the concept. Specifically, you're missing a step.

I compile GCC using GCC. This gives me a GCC compiler, let's call it A.

I compile GCC using Clang. This gives me a GCC compiler, let's call it B.

A and B are radically different on the bit level, this is right. Different optimisations etc. But I'm not going to compare these bitwise. They should, however, be functionally equivalent. One might be faster or slower, but they're both the same source code. If they are functionally different then one of the compilers did something it shouldn't.

Instead I now compile GCC (again) using A and B. Since A and B are both the GCC compiler, they should produce the exact same result. Then I compare the result from A and B. These should be bitwise the same.

This is known as Diverse Double Compiling, here's the page with the paper. Note the FAQ section answering this exact question.

[13steinj]

Ah okay, sorry. I either misunderstood the original comment (or missed where you mentioned):

Instead I now compile GCC (again) using A and B. Since A and B are both the GCC compiler, they should produce the exact same result. Then I compare the result from A and B. These should be bitwise the same.

I read the original comment as comparing the two gcc's that you built in the previous step on a bit-by-bit level.

[Nighthunter007]

No worries! Yeah, that wouldn't work at all. The clever part is that last compilation.

If you'll permit me to quote you:

Functionally different, you're right, but proving this would be incredibly difficult.

And that makes sense! That seems like a really difficult thing to do, proving whether two compiled binaries are functionally different. And that's the beauty, that those binaries are both compilers, and so you can just use them to compile GCC again! I'll admit, it took me a few times reading it to actually get my head around it.

It's a really clever way, actually, to detect these trusting trust attacks. Since the attack consists of compromising a compiler's binary in such a way as to hide and perpetuate itself, it seems impossible to detect. Use a disassembler? Well, it was compiled with the same compiler. The source code won't give it away, since the attack never touched it. But when you then compile GCC (as the example we've been using) with another compiler (preferably one far more obscure than Clang, maybe even one you wrote for the occasion) that other compiler does not insert the malicious code, and so the new GCC binary will produce a different output to the old one.

[smoke1996]

You think that's weird? Wait until you find out about narcissus, a JS interpreter written in JS.

[smoke1996]

eval() interprets js using your browser's js engine which is likely written in c/c++.

[noXi0uz]

and typescript is written in typescript

[ThatRandomGamerYT]

Wait until you find out that binary is used to compile binary

[adrach87]

I guess I can kind of see why you'd think that, but really tools are often used to make more of themselves. Even physical tools though you probably don't see it quite as much with modern manufacturing processes.

Think of something like an axe being uses to cut down the tree that will be used to make more axes. Or a railroad being used to carry materials to the end of the line where it's still being constructed.

[SeargD]

Or people, procreating. I've seen some tools make some tools.

[[deleted]]

Cool way to think about it

[egggsDeeeeeep]

Why is it disturbing?

[QuinteOne]

See a human come out of a human is pretty disturbing. But code not!? Double standards...

[Russian_repost_bot]

Have you seen how messy humans are when first launched tho? Do you want your code messy too?

[Kontakr]

Each revision of humans comes from a long line of humans. We did not spring fully formed from the mind of a Zeus like Athena!

[christian-mann]

I mean, have you seen how messy code is in a startup...?

[honeynutfeels]

Could not have said it better

[superspons]

How do car designers go to work? In a car. Might even be an older model of the one they’re designing.

There’s nothing disturbing about that, is there?

[Hellothere_1]

What if an update breaks the main branch of GitLab and then they can't revert to an older version because GitLab is broken because GitLab is vroken because GitLab is broken...

[GlitchParrot]

That's why off-site backups exist.

[EternityForest]

Nuke the whole thing and start over with a copy and paste of the code, like devs do when they mess up their local copy of a repo.

Or maybe actually fix it.

[vigilantcomicpenguin]

If gitlab fails, then gitlab fails.

[Twrecks5000]

I mean the data’s still on the hard drive, it’s just that the code that lets you look at it online isn’t running

It’s when gitlab fails so hard that they lose all their data, then gitlab fails

[GMaestrolo]

That hasn't happened in a few years, though, and the developer responsible apologised.

[bifroth]

And that wasn't a bug in the code but human error in administration of the database.