나트륨이 아닙니다, 소듐입니다.

// 데이터 쓰기
secureBuf.fill(0xAA)
console.log('Data written.')

// 1. 읽기 전용으로 변경 (sodium_mprotect_readonly)
sodium.sodium_mprotect_readonly(secureBuf)
console.log('Buffer is now Read-Only.')

// 쓰기 시도 시 프로세스가 종료될 수 있습니다.
secureBuf[0] = 0xFF; // This would crash or throw

// 2. 접근 금지로 변경 (sodium_mprotect_noaccess)
// 이 상태에서는 읽기/쓰기 모두 프로세스를 종료시킵니다.
sodium.sodium_mprotect_noaccess(secureBuf)
console.log('Buffer is now Inaccessible (No-Access).')

// 다시 사용하려면 권한을 복구해야 합니다.
sodium.sodium_mprotect_readwrite(secureBuf)
console.log('Buffer is Read-Write again.')

import sodium from 'sodium-native'

console.log('--- Key Exchange (KX) Example ---')

// 1. Server generates a keypair
const serverPublicKey = Buffer.alloc(sodium.crypto_kx_PUBLICKEYBYTES)
const serverSecretKey = Buffer.alloc(sodium.crypto_kx_SECRETKEYBYTES)
sodium.crypto_kx_keypair(serverPublicKey, serverSecretKey)
console.log('Server Public Key:', serverPublicKey.toString('hex'))

// 2. Client generates a keypair
const clientPublicKey = Buffer.alloc(sodium.crypto_kx_PUBLICKEYBYTES)
const clientSecretKey = Buffer.alloc(sodium.crypto_kx_SECRETKEYBYTES)
sodium.crypto_kx_keypair(clientPublicKey, clientSecretKey)
console.log('Client Public Key:', clientPublicKey.toString('hex'))

// 3. Client derives session keys
// Client needs: Client Public, Client Secret, Server Public
const clientRx = Buffer.alloc(sodium.crypto_kx_SESSIONKEYBYTES)
const clientTx = Buffer.alloc(sodium.crypto_kx_SESSIONKEYBYTES)
sodium.crypto_kx_client_session_keys(clientRx, clientTx, clientPublicKey, clientSecretKey, serverPublicKey)

// 4. Server derives session keys
// Server needs: Server Public, Server Secret, Client Public
const serverRx = Buffer.alloc(sodium.crypto_kx_SESSIONKEYBYTES)
const serverTx = Buffer.alloc(sodium.crypto_kx_SESSIONKEYBYTES)
sodium.crypto_kx_server_session_keys(serverRx, serverTx, serverPublicKey, serverSecretKey, clientPublicKey)

console.log('\n--- Session Keys Derived ---')
console.log('Client RX:', clientRx.toString('hex'))
console.log('Server TX:', serverTx.toString('hex'))
console.log('Match?', clientRx.equals(serverTx) ? '✅ Yes' : '❌ No')

console.log('Client TX:', clientTx.toString('hex'))
console.log('Server RX:', serverRx.toString('hex'))
console.log('Match?', clientTx.equals(serverRx) ? '✅ Yes' : '❌ No')

~ bun kx_example.ts                                                              
--- Key Exchange (KX) Example ---
Server Public Key: 05774cf2e23700b25c685d966dcc739cee456cafe1f2f2583f2eb71138ca792e
Client Public Key: b1f56d472e25a23fdfb9bd5b6113e3b07535654ccc357a3b731d0d372a999e31       

--- Session Keys Derived ---
Client RX: 39e42f9be55b1705bee32dca66049ec19e7827804944e3e4201d82ee4eec8b01
Server TX: 39e42f9be55b1705bee32dca66049ec19e7827804944e3e4201d82ee4eec8b01
Match? ✅ Yes
Client TX: 28e3a0590e41f8849b743d897d6e720a2a6ba6f89a6a094a7f812f95be5abb9e
Server RX: 28e3a0590e41f8849b743d897d6e720a2a6ba6f89a6a094a7f812f95be5abb9e
Match? ✅ Yes

const protocolHeader = Buffer.from('protocol-v1')
console.log('Using Protocol Header (AD):', protocolHeader.toString())

// 1. Client sends a message to Server
// Client encrypts using its TX key
const clientMessage = Buffer.from('Hello Server, this is Client!')
const clientNonce = Buffer.alloc(sodium.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES)
sodium.randombytes_buf(clientNonce)

const clientCiphertext = Buffer.alloc(clientMessage.length + sodium.crypto_aead_xchacha20poly1305_ietf_ABYTES)
sodium.crypto_aead_xchacha20poly1305_ietf_encrypt(clientCiphertext, clientMessage, protocolHeader, null, clientNonce, clientTx)

console.log('Client sends (encrypted):', clientCiphertext.toString('hex'))

// Server decrypts using its RX key
const serverDecrypted = Buffer.alloc(clientCiphertext.length - sodium.crypto_aead_xchacha20poly1305_ietf_ABYTES)
// Note: decrypt returns the length of the message on success, or throws/returns undefined on failure depending on binding.
// In sodium-native, it returns the length of the decrypted message, or throws if verification fails.
try {
    sodium.crypto_aead_xchacha20poly1305_ietf_decrypt(serverDecrypted, null, clientCiphertext, protocolHeader, clientNonce, serverRx)
    console.log('Server received (decrypted):', serverDecrypted.toString())
} catch (err) {
    console.error('Server failed to decrypt!', err)
}

// 2. Server responds to Client
// Server encrypts using its TX key
const serverMessage = Buffer.from('Hello Client, I received your message!')
const serverNonce = Buffer.alloc(sodium.crypto_aead_xchacha20poly1305_ietf_NPUBBYTES)
sodium.randombytes_buf(serverNonce)

const serverCiphertext = Buffer.alloc(serverMessage.length + sodium.crypto_aead_xchacha20poly1305_ietf_ABYTES)
sodium.crypto_aead_xchacha20poly1305_ietf_encrypt(serverCiphertext, serverMessage, protocolHeader, null, serverNonce, serverTx)

console.log('Server responds (encrypted):', serverCiphertext.toString('hex'))

// Client decrypts using its RX key
const clientDecrypted = Buffer.alloc(serverCiphertext.length - sodium.crypto_aead_xchacha20poly1305_ietf_ABYTES)
try {
    sodium.crypto_aead_xchacha20poly1305_ietf_decrypt(clientDecrypted, null, serverCiphertext, protocolHeader, serverNonce, clientRx)
    console.log('Client received (decrypted):', clientDecrypted.toString())
} catch (err) {
    console.error('Client failed to decrypt!', err)
}

import sodium from 'sodium-native'

// 1. Key Generation
const key = Buffer.alloc(sodium.crypto_secretstream_xchacha20poly1305_KEYBYTES)
sodium.crypto_secretstream_xchacha20poly1305_keygen(key)
console.log('Key generated:', key.toString('hex'))

// --- Sender Side ---
console.log('\n--- Sender: Encrypting Stream ---')

// Initialize Push Stream
const header = Buffer.alloc(sodium.crypto_secretstream_xchacha20poly1305_HEADERBYTES)
const stateOut = Buffer.alloc(sodium.crypto_secretstream_xchacha20poly1305_STATEBYTES)
sodium.crypto_secretstream_xchacha20poly1305_init_push(stateOut, header, key)

console.log('Header generated:', header.toString('hex'))

// Messages to send
const messages = [
  { text: 'Chunk 1: Hello', tag: sodium.crypto_secretstream_xchacha20poly1305_TAG_MESSAGE },
  { text: 'Chunk 2: World', tag: sodium.crypto_secretstream_xchacha20poly1305_TAG_MESSAGE },
  { text: 'Chunk 3: Final', tag: sodium.crypto_secretstream_xchacha20poly1305_TAG_FINAL }
]

const encryptedChunks: Buffer[] = []

for (const msg of messages) {
  const plaintext = Buffer.from(msg.text)
  const ciphertext = Buffer.alloc(plaintext.length + sodium.crypto_secretstream_xchacha20poly1305_ABYTES)
  
  sodium.crypto_secretstream_xchacha20poly1305_push(
    stateOut,
    ciphertext,
    plaintext,
    null, // AD (Optional)
    msg.tag
  )
  
  encryptedChunks.push(ciphertext)
  console.log(`Encrypted "${msg.text}" -> ${ciphertext.toString('hex')}`)
}


// --- Receiver Side ---
console.log('\n--- Receiver: Decrypting Stream ---')

// Initialize Pull Stream
const stateIn = Buffer.alloc(sodium.crypto_secretstream_xchacha20poly1305_STATEBYTES)
sodium.crypto_secretstream_xchacha20poly1305_init_pull(stateIn, header, key)

for (let i = 0; i < encryptedChunks.length; i++) {
  const ciphertext = encryptedChunks[i]
  const decrypted = Buffer.alloc(ciphertext.length - sodium.crypto_secretstream_xchacha20poly1305_ABYTES)
  const tagBuf = Buffer.alloc(sodium.crypto_secretstream_xchacha20poly1305_TAGBYTES) // To store the received tag
  
  try {
    const ret = sodium.crypto_secretstream_xchacha20poly1305_pull(
      stateIn,
      decrypted,
      tagBuf,
      ciphertext,
      null
    )
    
    if (ret === false) {
        throw new Error('Decryption failed (forged?)')
    }

    // The tag is written to tagBuf[0]
    const receivedTag = tagBuf[0]
    
    let tagStr = 'UNKNOWN'
    if (receivedTag === sodium.crypto_secretstream_xchacha20poly1305_TAG_MESSAGE) tagStr = 'MESSAGE'
    if (receivedTag === sodium.crypto_secretstream_xchacha20poly1305_TAG_PUSH) tagStr = 'PUSH'
    if (receivedTag === sodium.crypto_secretstream_xchacha20poly1305_TAG_REKEY) tagStr = 'REKEY'
    if (receivedTag === sodium.crypto_secretstream_xchacha20poly1305_TAG_FINAL) tagStr = 'FINAL'

    console.log(`Decrypted: "${decrypted.toString()}" [Tag: ${tagStr}]`)
    
    if (receivedTag === sodium.crypto_secretstream_xchacha20poly1305_TAG_FINAL) {
        console.log('End of stream reached.')
    }

  } catch (err) {
    console.error('Decryption error:', err)
  }
}

package main

import (
	"fmt"

	"github.com/awnumar/memguard"
)

func main() {
	defer memguard.SafeExit(0)
	memguard.CatchInterrupt()

	// 1. Generate a random key directly into a LockedBuffer
	key1 := memguard.NewBufferRandom(32)
	defer key1.Destroy()

	fmt.Printf("Key 1 (Random) Address: %p\n", key1)
	fmt.Printf("Key 1 Size: %d bytes\n", key1.Size())
	fmt.Printf("Key 1 Data (Hex): %x\n", key1.Bytes())

	// 2. Create a LockedBuffer from existing data
	sensitiveData := []byte("my-secret-password-1234")
	key2 := memguard.NewBufferFromBytes(sensitiveData)
	defer key2.Destroy()

	memguard.WipeBytes(sensitiveData)

	fmt.Printf("\nKey 2 (From Bytes) Address: %p\n", key2)
	fmt.Printf("Key 2 Data (String): %s\n", key2.Bytes())

	fmt.Println("\nAll buffers will be destroyed on exit.")
}

package main

import (
	"fmt"

	"github.com/awnumar/memguard"
)

func main() {
	defer memguard.SafeExit(0)
	memguard.CatchInterrupt()

	// 1. Create a LockedBuffer with sensitive data
	originalBuffer := memguard.NewBufferFromBytes([]byte("super-secret-enclave-data"))
	fmt.Printf("Original Buffer Address: %p\n", originalBuffer)
	fmt.Printf("Original Data: %s\n", originalBuffer.Bytes())

	// 2. Seal the buffer into an Enclave
	enclave := originalBuffer.Seal()
	fmt.Println("\nBuffer sealed into Enclave.")

	// originalBuffer은 이 시점에 파괴됩니다.
	// 명시적으로 originalBuffer.Destroy()를 호출할 필요가 없습니다..

	// 3. Open the Enclave to access data
	decryptedBuffer, err := enclave.Open()
	if err != nil {
		panic(err)
	}
	defer decryptedBuffer.Destroy() // 위 originalBuffer와 다른 LockedBuffer이기에 꼭 폭파시켜야합니다.

	fmt.Printf("\nDecrypted Buffer Address: %p\n", decryptedBuffer)
	fmt.Printf("Decrypted Data: %s\n", decryptedBuffer.Bytes())

	// 4. Enclave is reusable (immutable)
	decryptedBuffer2, _ := enclave.Open()
	defer decryptedBuffer2.Destroy()
	fmt.Printf("Opened again: %s\n", decryptedBuffer2.Bytes())

	fmt.Println("\nExiting safely...")
}

package secret

// Do invokes f.
//
// Do ensures that any temporary storage used by f is erased in a
// timely manner. (In this context, "f" is shorthand for the
// entire call tree initiated by f.)
//   - Any registers used by f are erased before Do returns.
//   - Any stack used by f is erased before Do returns.
//   - Any heap allocation done by f is erased as soon as the garbage
//     collector realizes that it is no longer reachable.
//   - Do works even if f panics or calls runtime.Goexit. As part of
//     that, any panic raised by f will appear as if it originates from
//     Do itself.
func Do(f func())

package main

import (
	"fmt"
    "runtime/secret"

	"github.com/awnumar/memguard"
)

func main() {
	defer memguard.SafeExit(0)
	memguard.CatchInterrupt()

	// 1. Create a LockedBuffer with sensitive data
	originalBuffer := memguard.NewBufferFromBytes([]byte("super-secret-enclave-data"))
	fmt.Printf("Original Buffer Address: %p\n", originalBuffer)
	fmt.Printf("Original Data: %s\n", originalBuffer.Bytes())

	// 2. Seal the buffer into an Enclave
	enclave := originalBuffer.Seal()
	fmt.Println("\nBuffer sealed into Enclave.")

	// originalBuffer은 이 시점에 파괴됩니다.
	// 명시적으로 originalBuffer.Destroy()를 호출할 필요가 없습니다..

	// 3. Open the Enclave to access data
    secret.Do(func() {
	    decryptedBuffer, err := enclave.Open()
	    if err != nil {
	    	panic(err)
	    }
	    defer decryptedBuffer.Destroy() // 위 originalBuffer와 다른 LockedBuffer이기에 꼭 폭파시켜야합니다.

	    fmt.Printf("\nDecrypted Buffer Address: %p\n", decryptedBuffer)
	    fmt.Printf("Decrypted Data: %s\n", decryptedBuffer.Bytes())
    })

	// 4. Enclave is reusable (immutable)
    secret.Do(func(){
	    decryptedBuffer2, _ := enclave.Open()
	    defer decryptedBuffer2.Destroy()
	    fmt.Printf("Opened again: %s\n", decryptedBuffer2.Bytes())
    })

	fmt.Println("\nExiting safely...")
}