A primeira versão incompatível do Git desde 2014

Autoria: Better Stack · Assistir no YouTube

Vídeo de autoria do canal indicado, não da IANIA; todos os direitos pertencem ao criador. Transcrição, resumo e tradução gerados automaticamente; o conteúdo no idioma original é preservado na versão em idioma original.

Idioma original: inglês

Vídeo original: Git’s First Breaking Release Since 2014 · Canal: Better Stack · 01:33 · Assistir no YouTube

Tópicos: Cibersegurança e segurança de software, Engenharia de software com IA, Open source e ecossistemas de software

Resumo

O Git 3 exigirá Rust e não permitirá desativá-lo, uma mudança motivada por questões de segurança de memória. A atualização também propõe trocar SHA-1 por SHA-256, o que aumentaria os hashes de commit de 40 para 64 caracteres e exigiria ajustes em scripts, CI e repositórios que usam submódulos. Scott, cofundador do GitHub, chamou a mudança de um pesadelo global, enquanto defensores da transição alertam que colisões de SHA-1 podem se tornar mais fáceis. Por enquanto, repositórios existentes não serão alterados, e ainda não há data oficial para o lançamento do Git 3.

Pontos-chave

O Git 3 exigirá Rust, que está ativado por padrão desde junho, e não será possível desativá-lo.
A mudança para Rust busca melhorar a segurança de memória, mas Rust não funciona em todas as plataformas compatíveis com Git.
A proposta de migração de SHA-1 para SHA-256 aumentaria os hashes de commit de 40 para 64 caracteres.
Scripts e configurações de CI que esperam hashes de 40 caracteres precisarão ser atualizados.
Um repositório SHA-256 não poderá usar um repositório SHA-1 como submódulo.
Scott, cofundador do GitHub, chamou a transição de um pesadelo global e argumentou que os hashes não garantem segurança.
Engenheiros do Git do Google ainda não se consideram prontos para a mudança e pretendem manter SHA-1 como padrão em suas configurações.
Repositórios existentes não serão alterados por enquanto, e ainda não há data oficial para o lançamento do Git 3.

Capítulos

Início	Capítulo	Resumo
00:00	Rust obrigatório no Git 3	O vídeo apresenta a exigência de Rust e explica que a mudança busca melhorar a segurança de memória, apesar de problemas de compatibilidade com algumas plataformas.
00:30	A proposta de trocar SHA-1 por SHA-256	A mudança aumentaria os hashes de commit para 64 caracteres e exigiria adaptações em scripts, CI e uso de submódulos.
01:03	Críticas, riscos e situação atual	O vídeo aborda a resistência à migração, o risco futuro de colisões de SHA-1 e a ausência de uma data oficial para o Git 3.

Citações

O Git 3 não será compilado sem Rust, e essa nem é a parte mais controversa desta atualização. — 00:00

Os hashes dos seus commits passarão de 40 caracteres para 64. — 00:30

A boa notícia, por enquanto, é que seus repositórios existentes não mudam. — 01:03

Conceitos e entidades

Git 3 (ferramenta): Versão futura do Git que, segundo o vídeo, exigirá Rust e propõe a migração de SHA-1 para SHA-256.
Git (ferramenta): Sistema de controle de versão discutido no vídeo.
Rust (conceito): Linguagem exigida pelo Git 3 para favorecer a segurança de memória.
SHA-1 (conceito): Algoritmo de hash usado pelo Git, cujas colisões são apontadas como uma preocupação de segurança.
SHA-256 (conceito): Algoritmo de hash proposto como substituto de SHA-1, com hashes de commit de 64 caracteres.
Scott (pessoa): Cofundador do GitHub que classificou a transição de hashes como um pesadelo global.
Linus (pessoa): Pessoa citada no vídeo como responsável por escolher SHA-1 em 2005 e por defender a importância da distribuição para a segurança.
GitHub (empresa): Empresa de hospedagem de código cujo cofundador Scott criticou a proposta de mudança de hashes.
Google (empresa): Empresa cujos engenheiros de Git, segundo o vídeo, ainda não estão prontos para a mudança para SHA-256.

Tradução completa (pt-BR)

00:00 O Git 3 não vai compilar sem Rust, e essa nem é a parte mais controversa desta atualização. Na verdade, este é o primeiro lançamento com mudanças incompatíveis do Git desde 2014 e, embora o Rust esteja ativado por padrão desde junho, com o Git 3 você não poderá desativá-lo. A equipe fez essa mudança por segurança de memória. Um grande número de problemas de segurança do Git envolveu bugs de memória, mas o problema é que Rust não funciona em todas as plataformas em que o Git funciona. Por isso, fizeram com que a última versão anterior à 3 tivesse suporte de longo prazo. Mas a mudança maior e mais controversa desta atualização envolve hashes. Linus escolheu SHA-1 em 2005, mas

00:30 hoje em dia, as pessoas conseguem de fato quebrar isso fazendo com que dois arquivos diferentes tenham o mesmo hash SHA-1. Então, agora querem mudar para SHA-256, e os hashes dos seus commits passarão de 40 caracteres para 64. O motivo de as pessoas estarem chateadas com isso é que todo script ou hash de CI que espera 40 caracteres vai precisar ser atualizado, e qualquer repo SHA-256 não poderá usar um repo SHA-1 como submódulo. Scott, que cofundou o GitHub, chamou isso de um pesadelo global. O argumento dele era que os hashes, na verdade, nunca mantiveram você seguro. Até Linus disse, em 2005, que a segurança real está na distribuição.

01:03 Scott argumenta que subornar um mantenedor cansado para obter acesso a um repo provavelmente é mais fácil do que explorar o SHA-1. Até os próprios engenheiros do Git do Google dizem que não estão prontos; eles simplesmente vão mudar o padrão de volta para SHA-1 na configuração deles. Mas ele também alerta que as colisões só vão ficar mais fáceis no futuro. Então, quando o SHA-1 realmente quebrar, todo o setor vai ficar correndo para resolver o problema e terá que fazer algumas mudanças indesejadas. A boa notícia, por enquanto, é que seus repos existentes não mudam, e ainda não há uma data oficial de lançamento para o Git 3, mas você já pode experimentar hashes SHA-256 com um simples comando do Git. Me contem nos

01:33 comentários o que vocês acham disso e inscrevam-se para ficar por dentro das novidades para desenvolvedores.

Transcrição original

[00:00] Git 3 won’t build without Rust, and that’s not even the most controversial part in this update. This is actually Git’s first breaking release since 2014, and although Rust has been on by default since June, with Git 3, you won’t be able to turn it off. The reason the team made this change was for memory safety. A large number of Git security issues have been memory bugs, but the trouble is Rust doesn’t run on every platform that Git does, so they made the last version before 3 get long-term support. But the bigger, more controversial change in this update is with hashes. Linus picked SHA-1 back in 2005, but

[00:30] nowadays people can actually break this by getting two different files to share the same SHA-1 hash. So now they want to switch to SHA-256, so your commit hashes will go from 40 characters to 64. The reason people are upset by this is because every script rejects or CI hash that expects 40 characters is going to need to be updated, and any SHA-256 repo won’t be able to use a SHA-1 repo as a submodule. Scott, who co-founded GitHub, called this a global nightmare. His argument was that the hashes actually never kept you safe. Even Linus said in 2005 real security is in distribution.

[01:03] Scott argues that bribing a tired maintainer for access to a repo is probably easier than a SHA-1 exploit. Even Google’s own Git engineers says that they’re not ready, they’ll just switch the default back to SHA-1 in their config. But he does also warn that collisions will only get easier in the future, so when SHA-1 does really break, the whole industry is going to be left scrambling, and they’re going to have to make some unwanted changes. The good news for now though is that your existing repos don’t change, and there’s no official release date for Git 3 yet, but you can actually try SHA-256 hashes now with a simple Git command. Let me know what you think about this in the

[01:33] comments, and subscribe to stay up-to-date with developer news.