Andrew Ayer

Direct link to the comment: https://bugzilla.mozilla.org/show_bug.cgi?id=1910322#c10 The author of that comment is Andrew Ayer, who also does great writeups about CA incidents and processes on his blog: https://www.agwa.name/blog/index

100% agree. It's such a versatile tool -- for example I have the following: git config --local core.hooksPath $PWD/.githooks export DOCKER_CONFIG=$(realpath secrets/docker) Combine that with git-crypt[0] (obviously, don't commit secrets in plaintext to your repo!) for example and you have some really nice ergonomics. Not enough people know about direnv. [0]: https://www.agwa.name/projects/git-crypt/

These different representations also lead to frequent server side request forgery (SSRF) bypasses - someone might be blocking local IPv4 but you can still access their AWS metadata endpoint at ::ffff:169.254.169.254, etc. For anyone using Ruby, I'm the author of a gem [1] that comprehensively protects against SSRF bugs. For anyone using Golang I recommend this [2] blog post. [1]: https://github.com/arkadiyt/ssrf_filter [2]: https://www.agwa.name/blog/post/preventing_server_side_request_forgery…

> UPDATE: Before people ask the potential question how the researchers are supposed to get their proper credit - my consideration is the following: Each of the researchers signs the paper with their own "public" key of a public-private key pair. This signature is uploaded as part of the paper upload. The "public" key is nevertheless kept secret by the researchers. > When the legal risk is over and the researchers want to disclose their contribution, they simply make their "public" key really public. This way, anyboy can change that the signature that was uploaded from beginning on, indeed belong to this public key and thus to the respective researcher. Commonly-used public key signature systems (RSA, ECDSA) do not provide the security properties necessary for this. Someone else who wants to claim credit for the research could cook up their own key pair that successfully validates the message and signature. This is called a duplicate signature key selection attack (https://www.agwa.name/blog/post/duplicate_signature_key_selection_atta…

I use git-crypt to encrypt the inputs in my public repo https://www.agwa.name/projects/git-crypt/ :)

SSL added and removed here! :-) https://www.agwa.name/blog/post/cloudflare_ssl_added_and_removed_here

Nobody remembers the "SSL added and removed here :)"? https://www.agwa.name/blog/post/cloudflare_ssl_added_and_removed_here/…

You may wish to consider these also; git-crypt - https://www.agwa.name/projects/git-crypt/ Or blackbox - https://github.com/StackExchange/blackbox

SSH keys can now be used to sign arbitrary content, so any github user with a published key is now able to publish verified content that can be verified offline. https://www.agwa.name/blog/post/ssh_signatures

Generally, no; in this particular case (SSH authentication and generic signatures), it seems to be ok: https://www.agwa.name/blog/post/ssh_signatures

It's Now Possible To Sign Arbitrary Data With Your SSH Keys: https://www.agwa.name/blog/post/ssh_signatures

This is a pretty good article about preventing SSRF including DNS rebinding-based attacks in Go https://www.agwa.name/blog/post/preventing_server_side_request_forgery…

These kinds of attacks are usually run by a major threat actor (i.e. nation state), targeted, and not run at large scale. Certificate transparency is unlikely to help in this case. Key pinning was the more secure option. For some issues see: https://www.agwa.name/blog/post/how_will_certificate_transparency_logs… https://tools.ietf.org/html/draft-ietf-trans-threat-analysis-16

It’s not assuming MITM or that the attacker can upload the signature to the site. The attack is that the attacker can reuse the already uploaded signature in a way that allows them to get certificates issued under their account instead of the initial owner. This blog is a little confusing about that since it does read like they are supposed to upload their own sig with the graphic used. This post and linked IETF report is a little more clear: https://www.agwa.name/blog/2015/12

The article neglects the details of crafting the private key which are provided in the original blog post: https://www.agwa.name/blog/2015/12 IMO crafting the public key alone does not provide the attacker significant benefits.

This is about the same library: https://www.agwa.name/blog/post/always_review_your_dependencies Claims there are it's written by people who don't understand Go that well.

This is one of the threats addressed by https://www.certificate-transparency.org/ . If a CA issues a rogue cert and _does_ add it to the CT log, it's discoverable, at least in retrospect. If a CA issues a rogue cert and _doesn't_ add it to the log, some browsers will refuse the connection when presented with that cert. https://www.agwa.name/blog/post/how_will_certificate_transparency_logs… has more details about Chrome's implementation.

For project-specific secrets, you may want to look at git-crypt: https://www.agwa.name/projects/git-crypt/

They can be defined in either. For example, see https://www.agwa.name/projects/git-crypt/.

If anyone wants to keep secrets in a repo, git-crypt is your friend: https://www.agwa.name/projects/git-crypt/

git-crypt[1] is quite handy in cases where the credentials have to live along the code. It's a nice improvement over having credentials in clear in a git repo and relatively easy to implement. [1]: https://www.agwa.name/projects/git-crypt/

David Strauss is one of the systemd developers that don't work at Red Hat. It has its problems too: https://www.agwa.name/blog/post/thoughts_on_the_systemd_root_exploit Not to mention Kay Sievers which was even hated by Linus Torvalds: https://lkml.org/lkml/2014/4/2/420

I've basically decided systemd isn't for me and have uninstalled it from my systems. The last straw for me was a recent security issue: https://www.agwa.name/blog/post/how_to_crash_systemd_in_one_tweet Which made me re-evaluate systemd. Fundamentally creating a monolithic tool to take over from many small single purpose tools seems counter to the UNIX philosophy, and makes it harder to hack on my (mostly desktop/laptop) systems.

"Systemd is far more than an init system: it is becoming a secondary operating system kernel, providing a log server, a device manager, a container manager, a login manager, a DHCP client, a DNS resolver, and an NTP client. These services are largely interdependent and provide non-standard interfaces for other applications to use. This makes any one component of systemd hard to replace, which will prevent more secure alternatives from gaining adoption in the future." [1] "There will be better alternatives in the future that are more secure than what we have now. But adopting them will only be possible if systemd has not destroyed the modularity and standards-compliance that make innovation possible" [1] [1] https://www.agwa.name/blog/post/how_to_crash_systemd_in_one_tweet

I've seen quite a bit of criticism of it for mail servers [1] because an attacker can simply block the 'STARTTLS' message and (many) clients will silently accept that. [1] https://www.agwa.name/blog/post/starttls_considered_harmful

Related: The software's author's original post: https://www.agwa.name/projects/git-crypt/

I think that if you're using git, use git crypt[1][2] use git-dir and work-tree options/env vars [1] https://www.agwa.name/projects/git-crypt/ [2] though you have to remember to git crypt lock

git-crypt[1] also does per file encryption [1]: https://www.agwa.name/projects/git-crypt/

Any truth in this? https://www.agwa.name/blog/post/starttls_considered_harmful

> Actually, this might not come as surprise to you... Probably not, given he has a link to that same email as one of the very first things in his README. > ...but there are a few reasons you should not do this Having read the thread, it seems that everyone is talking about encrypting an entire repository in such a way, where as this project and (the surprisingly similar) git-crypt[1] are designed to encrypt only a few select files inside a repo--which isn't going to impact the git packer's compression techniques too much. [1] http://www.agwa.name/projects/git-crypt/