Wala shell

Advanced PHP File Manager

Server IP: 127.0.0.1 | PHP Version: 8.3.30 | Domains Hosted: 54

Name	Size	Last Modified	Actions
📁 ..	-	2025-05-25 12:27
📄 box.go // Copyright 2012 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. /* Package box authenticates and encrypts small messages using public-key cryptography. Box uses Curve25519, XSalsa20 and Poly1305 to encrypt and authenticate messages. The length of messages is not hidden. It is the caller's responsibility to ensure the uniqueness of nonces—for example, by using nonce 1 for the first message, nonce 2 for the second message, etc. Nonces are long enough that randomly generated nonces have negligible risk of collision. Messages should be small because: 1. The whole message needs to be held in memory to be processed. 2. Using large messages pressures implementations on small machines to decrypt and process plaintext before authenticating it. This is very dangerous, and this API does not allow it, but a protocol that uses excessive message sizes might present some implementations with no other choice. 3. Fixed overheads will be sufficiently amortised by messages as small as 8KB. 4. Performance may be improved by working with messages that fit into data caches. Thus large amounts of data should be chunked so that each message is small. (Each message still needs a unique nonce.) If in doubt, 16KB is a reasonable chunk size. This package is interoperable with NaCl: https://nacl.cr.yp.to/box.html. Anonymous sealing/opening is an extension of NaCl defined by and interoperable with libsodium: https://libsodium.gitbook.io/doc/public-key_cryptography/sealed_boxes. / package box import ( cryptorand "crypto/rand" "io" "golang.org/x/crypto/blake2b" "golang.org/x/crypto/curve25519" "golang.org/x/crypto/nacl/secretbox" "golang.org/x/crypto/salsa20/salsa" ) const ( // Overhead is the number of bytes of overhead when boxing a message. Overhead = secretbox.Overhead // AnonymousOverhead is the number of bytes of overhead when using anonymous // sealed boxes. AnonymousOverhead = Overhead + 32 ) // GenerateKey generates a new public/private key pair suitable for use with // Seal and Open. func GenerateKey(rand io.Reader) (publicKey, privateKey [32]byte, err error) { publicKey = new([32]byte) privateKey = new([32]byte) _, err = io.ReadFull(rand, privateKey[:]) if err != nil { publicKey = nil privateKey = nil return } curve25519.ScalarBaseMult(publicKey, privateKey) return } var zeros [16]byte // Precompute calculates the shared key between peersPublicKey and privateKey // and writes it to sharedKey. The shared key can be used with // OpenAfterPrecomputation and SealAfterPrecomputation to speed up processing // when using the same pair of keys repeatedly. func Precompute(sharedKey, peersPublicKey, privateKey [32]byte) { curve25519.ScalarMult(sharedKey, privateKey, peersPublicKey) salsa.HSalsa20(sharedKey, &zeros, sharedKey, &salsa.Sigma) } // Seal appends an encrypted and authenticated copy of message to out, which // will be Overhead bytes longer than the original and must not overlap it. The // nonce must be unique for each distinct message for a given pair of keys. func Seal(out, message []byte, nonce [24]byte, peersPublicKey, privateKey [32]byte) []byte { var sharedKey [32]byte Precompute(&sharedKey, peersPublicKey, privateKey) return secretbox.Seal(out, message, nonce, &sharedKey) } // SealAfterPrecomputation performs the same actions as Seal, but takes a // shared key as generated by Precompute. func SealAfterPrecomputation(out, message []byte, nonce [24]byte, sharedKey [32]byte) []byte { return secretbox.Seal(out, message, nonce, sharedKey) } // Open authenticates and decrypts a box produced by Seal and appends the // message to out, which must not overlap box. The output will be Overhead // bytes smaller than box. func Open(out, box []byte, nonce [24]byte, peersPublicKey, privateKey [32]byte) ([]byte, bool) { var sharedKey [32]byte Precompute(&sharedKey, peersPublicKey, privateKey) return secretbox.Open(out, box, nonce, &sharedKey) } // OpenAfterPrecomputation performs the same actions as Open, but takes a // shared key as generated by Precompute. func OpenAfterPrecomputation(out, box []byte, nonce [24]byte, sharedKey [32]byte) ([]byte, bool) { return secretbox.Open(out, box, nonce, sharedKey) } // SealAnonymous appends an encrypted and authenticated copy of message to out, // which will be AnonymousOverhead bytes longer than the original and must not // overlap it. This differs from Seal in that the sender is not required to // provide a private key. func SealAnonymous(out, message []byte, recipient [32]byte, rand io.Reader) ([]byte, error) { if rand == nil { rand = cryptorand.Reader } ephemeralPub, ephemeralPriv, err := GenerateKey(rand) if err != nil { return nil, err } var nonce [24]byte if err := sealNonce(ephemeralPub, recipient, &nonce); err != nil { return nil, err } if total := len(out) + AnonymousOverhead + len(message); cap(out) < total { original := out out = make([]byte, 0, total) out = append(out, original...) } out = append(out, ephemeralPub[:]...) return Seal(out, message, &nonce, recipient, ephemeralPriv), nil } // OpenAnonymous authenticates and decrypts a box produced by SealAnonymous and // appends the message to out, which must not overlap box. The output will be // AnonymousOverhead bytes smaller than box. func OpenAnonymous(out, box []byte, publicKey, privateKey [32]byte) (message []byte, ok bool) { if len(box) < AnonymousOverhead { return nil, false } var ephemeralPub [32]byte copy(ephemeralPub[:], box[:32]) var nonce [24]byte if err := sealNonce(&ephemeralPub, publicKey, &nonce); err != nil { return nil, false } return Open(out, box[32:], &nonce, &ephemeralPub, privateKey) } // sealNonce generates a 24 byte nonce that is a blake2b digest of the // ephemeral public key and the receiver's public key. func sealNonce(ephemeralPub, peersPublicKey [32]byte, nonce *[24]byte) error { h, err := blake2b.New(24, nil) if err != nil { return err } if _, err = h.Write(ephemeralPub[:]); err != nil { return err } if _, err = h.Write(peersPublicKey[:]); err != nil { return err } h.Sum(nonce[:0]) return nil }	6.09 KB	2025-05-25 12:27
📄 box_test.go // Copyright 2012 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. package box import ( "bytes" "crypto/rand" "encoding/hex" "testing" "golang.org/x/crypto/curve25519" ) func TestSealOpen(t testing.T) { publicKey1, privateKey1, _ := GenerateKey(rand.Reader) publicKey2, privateKey2, _ := GenerateKey(rand.Reader) if privateKey1 == privateKey2 { t.Fatalf("private keys are equal!") } if publicKey1 == publicKey2 { t.Fatalf("public keys are equal!") } message := []byte("test message") var nonce [24]byte box := Seal(nil, message, &nonce, publicKey1, privateKey2) opened, ok := Open(nil, box, &nonce, publicKey2, privateKey1) if !ok { t.Fatalf("failed to open box") } if !bytes.Equal(opened, message) { t.Fatalf("got %x, want %x", opened, message) } for i := range box { box[i] ^= 0x40 _, ok := Open(nil, box, &nonce, publicKey2, privateKey1) if ok { t.Fatalf("opened box with byte %d corrupted", i) } box[i] ^= 0x40 } } func TestBox(t testing.T) { var privateKey1, privateKey2 [32]byte for i := range privateKey1[:] { privateKey1[i] = 1 } for i := range privateKey2[:] { privateKey2[i] = 2 } var publicKey1 [32]byte curve25519.ScalarBaseMult(&publicKey1, &privateKey1) var message [64]byte for i := range message[:] { message[i] = 3 } var nonce [24]byte for i := range nonce[:] { nonce[i] = 4 } box := Seal(nil, message[:], &nonce, &publicKey1, &privateKey2) // expected was generated using the C implementation of NaCl. expected, _ := hex.DecodeString("78ea30b19d2341ebbdba54180f821eec265cf86312549bea8a37652a8bb94f07b78a73ed1708085e6ddd0e943bbdeb8755079a37eb31d86163ce241164a47629c0539f330b4914cd135b3855bc2a2dfc") if !bytes.Equal(box, expected) { t.Fatalf("box didn't match, got\n%x\n, expected\n%x", box, expected) } } func TestSealOpenAnonymous(t testing.T) { publicKey, privateKey, _ := GenerateKey(rand.Reader) message := []byte("test message") box, err := SealAnonymous(nil, message, publicKey, nil) if err != nil { t.Fatalf("Unexpected error sealing %v", err) } opened, ok := OpenAnonymous(nil, box, publicKey, privateKey) if !ok { t.Fatalf("failed to open box") } if !bytes.Equal(opened, message) { t.Fatalf("got %x, want %x", opened, message) } for i := range box { box[i] ^= 0x40 _, ok := OpenAnonymous(nil, box, publicKey, privateKey) if ok { t.Fatalf("opened box with byte %d corrupted", i) } box[i] ^= 0x40 } // allocates new slice if out isn't long enough out := []byte("hello") orig := append([]byte(nil), out...) box, err = SealAnonymous(out, message, publicKey, nil) if err != nil { t.Fatalf("Unexpected error sealing %v", err) } if !bytes.Equal(out, orig) { t.Fatal("expected out to be unchanged") } if !bytes.HasPrefix(box, orig) { t.Fatal("expected out to be coppied to returned slice") } _, ok = OpenAnonymous(nil, box[len(out):], publicKey, privateKey) if !ok { t.Fatalf("failed to open box") } // uses provided slice if it's long enough out = append(make([]byte, 0, 1000), []byte("hello")...) orig = append([]byte(nil), out...) box, err = SealAnonymous(out, message, publicKey, nil) if err != nil { t.Fatalf("Unexpected error sealing %v", err) } if !bytes.Equal(out, orig) { t.Fatal("expected out to be unchanged") } if &out[0] != &box[0] { t.Fatal("expected box to point to out") } _, ok = OpenAnonymous(nil, box[len(out):], publicKey, privateKey) if !ok { t.Fatalf("failed to open box") } } func TestSealedBox(t testing.T) { var privateKey [32]byte for i := range privateKey[:] { privateKey[i] = 1 } var publicKey [32]byte curve25519.ScalarBaseMult(&publicKey, &privateKey) var message [64]byte for i := range message[:] { message[i] = 3 } fakeRand := bytes.NewReader([]byte{5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5}) box, err := SealAnonymous(nil, message[:], &publicKey, fakeRand) if err != nil { t.Fatalf("Unexpected error sealing %v", err) } // expected was generated using the C implementation of libsodium with a // random implementation that always returns 5. // https://gist.github.com/mastahyeti/942ec3f175448d68fed25018adbce5a7 expected, _ := hex.DecodeString("50a61409b1ddd0325e9b16b700e719e9772c07000b1bd7786e907c653d20495d2af1697137a53b1b1dfc9befc49b6eeb38f86be720e155eb2be61976d2efb34d67ecd44a6ad634625eb9c288bfc883431a84ab0f5557dfe673aa6f74c19f033e648a947358cfcc606397fa1747d5219a") if !bytes.Equal(box, expected) { t.Fatalf("box didn't match, got\n%x\n, expected\n%x", box, expected) } // box was generated using the C implementation of libsodium. // https://gist.github.com/mastahyeti/942ec3f175448d68fed25018adbce5a7 box, _ = hex.DecodeString("3462e0640728247a6f581e3812850d6edc3dcad1ea5d8184c072f62fb65cb357e27ffa8b76f41656bc66a0882c4d359568410665746d27462a700f01e314f382edd7aae9064879b0f8ba7b88866f88f5e4fbd7649c850541877f9f33ebd25d46d9cbcce09b69a9ba07f0eb1d105d4264") result, ok := OpenAnonymous(nil, box, &publicKey, &privateKey) if !ok { t.Fatalf("failed to open box") } if !bytes.Equal(result, message[:]) { t.Fatalf("message didn't match, got\n%x\n, expected\n%x", result, message[:]) } }	5.18 KB	2025-05-25 12:27
📄 example_test.go package box_test import ( crypto_rand "crypto/rand" // Custom so it's clear which rand we're using. "fmt" "io" "golang.org/x/crypto/nacl/box" ) func Example() { senderPublicKey, senderPrivateKey, err := box.GenerateKey(crypto_rand.Reader) if err != nil { panic(err) } recipientPublicKey, recipientPrivateKey, err := box.GenerateKey(crypto_rand.Reader) if err != nil { panic(err) } // You must use a different nonce for each message you encrypt with the // same key. Since the nonce here is 192 bits long, a random value // provides a sufficiently small probability of repeats. var nonce [24]byte if _, err := io.ReadFull(crypto_rand.Reader, nonce[:]); err != nil { panic(err) } msg := []byte("Alas, poor Yorick! I knew him, Horatio") // This encrypts msg and appends the result to the nonce. encrypted := box.Seal(nonce[:], msg, &nonce, recipientPublicKey, senderPrivateKey) // The recipient can decrypt the message using their private key and the // sender's public key. When you decrypt, you must use the same nonce you // used to encrypt the message. One way to achieve this is to store the // nonce alongside the encrypted message. Above, we stored the nonce in the // first 24 bytes of the encrypted text. var decryptNonce [24]byte copy(decryptNonce[:], encrypted[:24]) decrypted, ok := box.Open(nil, encrypted[24:], &decryptNonce, senderPublicKey, recipientPrivateKey) if !ok { panic("decryption error") } fmt.Println(string(decrypted)) // Output: Alas, poor Yorick! I knew him, Horatio } func Example_precompute() { senderPublicKey, senderPrivateKey, err := box.GenerateKey(crypto_rand.Reader) if err != nil { panic(err) } recipientPublicKey, recipientPrivateKey, err := box.GenerateKey(crypto_rand.Reader) if err != nil { panic(err) } // The shared key can be used to speed up processing when using the same // pair of keys repeatedly. sharedEncryptKey := new([32]byte) box.Precompute(sharedEncryptKey, recipientPublicKey, senderPrivateKey) // You must use a different nonce for each message you encrypt with the // same key. Since the nonce here is 192 bits long, a random value // provides a sufficiently small probability of repeats. var nonce [24]byte if _, err := io.ReadFull(crypto_rand.Reader, nonce[:]); err != nil { panic(err) } msg := []byte("A fellow of infinite jest, of most excellent fancy") // This encrypts msg and appends the result to the nonce. encrypted := box.SealAfterPrecomputation(nonce[:], msg, &nonce, sharedEncryptKey) // The shared key can be used to speed up processing when using the same // pair of keys repeatedly. var sharedDecryptKey [32]byte box.Precompute(&sharedDecryptKey, senderPublicKey, recipientPrivateKey) // The recipient can decrypt the message using the shared key. When you // decrypt, you must use the same nonce you used to encrypt the message. // One way to achieve this is to store the nonce alongside the encrypted // message. Above, we stored the nonce in the first 24 bytes of the // encrypted text. var decryptNonce [24]byte copy(decryptNonce[:], encrypted[:24]) decrypted, ok := box.OpenAfterPrecomputation(nil, encrypted[24:], &decryptNonce, &sharedDecryptKey) if !ok { panic("decryption error") } fmt.Println(string(decrypted)) // Output: A fellow of infinite jest, of most excellent fancy }	3.28 KB	2025-05-25 12:27

Terminal