Vietnamese (machine translation)

Lưu ý

Mục đích của file này là để độc giả tiếng Việt có thể đọc và hiểu tài liệu nhân kernel dễ dàng hơn, không phải để tạo ra một nhánh tài liệu riêng. Nếu bạn có bất kỳ nhận xét hoặc cập nhật nào cho file này, vui lòng thử cập nhật file tiếng Anh gốc trước. Nếu bạn thấy có sự khác biệt giữa bản dịch và bản gốc, hoặc có vấn đề về bản dịch, vui lòng gửi góp ý hoặc patch cho người dịch của file này, hoặc nhờ người bảo trì và người review tài liệu tiếng Việt giúp đỡ.

Bản gốc:

Code Examples

Người dịch:

Google Translate (machine translation)

Phiên bản gốc:

8541d8f725c6

Cảnh báo

Tài liệu này được dịch tự động bằng máy và chưa được review bởi người dịch. Nội dung có thể không chính xác hoặc khó hiểu ở một số chỗ. Khi có sự khác biệt với bản gốc, bản gốc luôn là chuẩn. Bản dịch chất lượng cao (được review) được đặt trong thư mục vi_VN/.

Ví dụ về mã

Ví dụ về mã cho hoạt động mã hóa khóa đối xứng

Mã này mã hóa một số dữ liệu bằng AES-256-XTS. Vì ví dụ, tất cả đầu vào đều là byte ngẫu nhiên, quá trình mã hóa được thực hiện tại chỗ và giả sử mã đang chạy trong ngữ cảnh có thể ngủ.

int tĩnh test_skcipher(void)
{

struct crypto_skcipher tfm = NULL; struct skcipher_request *req = NULL; u8 *dữ liệu = NULL; const size_t datasize = 512; /*Kích thước dữ liệu tính bằng byte */ danh sách phân tán cấu trúc sg; DECLARE_CRYPTO_WAIT(chờ); u8 iv[16]; / AES-256-XTS lấy IV 16 byte / phím u8[64]; / AES-256-XTS lấy khóa 64 byte */ int lỗi;

/*

  • Phân bổ một tfm (một đối tượng chuyển đổi) và đặt khóa.

  • Trong sử dụng thực tế, tfm và key thường được sử dụng cho nhiều mục đích

  • hoạt động mã hóa/giải mã. Nhưng trong ví dụ này, chúng ta sẽ chỉ làm một

  • hoạt động mã hóa đơn lẻ với nó (không hiệu quả lắm).

*/

tfm = crypto_alloc_skcipher(“xts(aes)”, 0, 0);
nếu (IS_ERR(tfm)) {

pr_err(“Lỗi cấp phát xts(aes) xử lý: %ldn”, PTR_ERR(tfm)); trả về PTR_ERR(tfm);

}

get_random_bytes(key, sizeof(key));

err = crypto_skcipher_setkey(tfm, key, sizeof(key)); nếu (lỗi) {

pr_err(“Lỗi cài đặt khóa: %dn”, err); đi ra ngoài;

}

/* Phân bổ đối tượng yêu cầu */

req = skcipher_request_alloc(tfm, GFP_KERNEL); nếu (!req) {

lỗi = -ENOMEM; đi ra ngoài;

}

/Chuẩn bị dữ liệu đầu vào/

dữ liệu = kmalloc(datasize, GFP_KERNEL); nếu (!dữ liệu) {

lỗi = -ENOMEM; đi ra ngoài;

} get_random_bytes(dữ liệu, kích thước dữ liệu);

/* Khởi tạo IV */

get_random_bytes(iv, sizeof(iv));

/*

  • Mã hóa dữ liệu tại chỗ.

  • Để đơn giản, trong ví dụ này chúng ta đợi request hoàn thành

  • trước khi tiếp tục, ngay cả khi việc triển khai cơ bản không đồng bộ.

  • Để giải mã thay vì mã hóa, chỉ cần thay đổi crypto_skcipher_encrypt() thành

  • crypto_skcipher_decrypt().

*/

sg_init_one(&sg, dữ liệu, kích thước dữ liệu); skcipher_request_set_callback(req, CRYPTO_TFM_REQ_MAY_BACKLOG |

CRYPTO_TFM_REQ_MAY_SLEEP,

crypto_req_done, &đợi);

skcipher_request_set_crypt(req, &sg, &sg, datasize, iv); err = crypto_wait_req(crypto_skcipher_encrypt(req), &wait); nếu (lỗi) {

pr_err(“Lỗi mã hóa dữ liệu: %dn”, err); đi ra ngoài;

}

pr_debug(“Mã hóa thành côngn”);
ra:

crypto_free_skcipher(tfm); skcipher_request_free(req); kfree(dữ liệu); trả lại lỗi;

}

Ví dụ mã để sử dụng bộ nhớ trạng thái hoạt động với SHASH

cấu trúc sdesc {

cấu trúc shash_desc shash; char ctx[];

};

cấu trúc tĩnh sdesc *init_sdesc(struct crypto_shash *alg)
{

cấu trúc sdesc *sdesc; kích thước int;

kích thước = sizeof(struct shash_desc) + crypto_shash_descsize(alg);

sdesc = kmalloc(kích thước, GFP_KERNEL); nếu (!sdesc)

trả về ERR_PTR(-ENOMEM);

sdesc->shash.tfm = alg; trả về sdesc;

}

int tĩnh calc_hash(struct crypto_shash *alg,

const dữ liệu char * không dấu, dữ liệu int không dấu, ký tự không dấu *tiêu hóa)

{

cấu trúc sdesc *sdesc; int ret;

sdesc = init_sdesc(alg);
nếu (IS_ERR(sdesc)) {

pr_info(“không thể cấp phát sdescn”); trả về PTR_ERR(sdesc);

}

ret = crypto_shash_digest(&sdesc->shash, data, datalen, dig);

kfree(sdesc); trở lại ret;

}

static int test_hash(const unsigned char *data, unsigned int datalen,

ký tự không dấu *tiêu hóa)

{

struct crypto_shash *alg; char *hash_alg_name = “sha1-padlock-nano”; int ret;

alg = crypto_alloc_shash(hash_alg_name, 0, 0);
nếu (IS_ERR(alg)) {

pr_info(“không thể cấp phát alg %sn”, hash_alg_name); trả về PTR_ERR(alg);

} ret = calc_hash(alg, data, datalen, dig); crypto_free_shash(alg); trở lại ret;

}

Ví dụ về mã để sử dụng trình tạo số ngẫu nhiên

int tĩnh get_random_numbers(u8 *buf, unsigned int len)
{

struct crypto_rng *rng = NULL; char ZZ0000ZZ Hash DRBG với SHA-256, không có PR */ int ret;

if (!buf || !len) {

pr_debug(“Không cung cấp bộ đệm đầu ran”); trả về -EINVAL;

}

rng = crypto_alloc_rng(drbg, 0, 0);
nếu (IS_ERR(rng)) {

pr_debug(“không thể phân bổ bộ xử lý RNG cho %sn”, drbg); trả về PTR_ERR(rng);

}

ret = crypto_rng_get_bytes(rng, buf, len);
nếu (ret < 0)

pr_debug(“tạo số ngẫu nhiên không thành côngn”);

khác nếu (ret == 0)

pr_debug(“RNG không trả về dữ liệu”);

khác

pr_debug(“RNG trả về %d byte dữ liệun”, ret);

ra:

crypto_free_rng(rng); trở lại ret;

}