C 언어 압축 파일 과 MD5 알고리즘 으로 파일 의 완전 성 을 검증 하 는 인 스 턴 스 튜 토리 얼
때때로 우 리 는 단순히 lzma 알고리즘 이 압축 된 7z 파일 에 대해 압축 을 풀 어야 합 니 다.때로는 내장 장치 에서 압축 을 풀 어야 합 니 다.p7zip 을 사용 하면 여러 가지 형식 을 지원 하지만 재단 이 쉽 지 않 습 니 다.lzma SDK 를 사용 하 는 것 이 좋 습 니 다.
여기에서 여러 가지 버 전 을 찾 을 수 있 습 니 다.http://zh.sourceforge.jp/projects/sfnet_sevenzip/releases/
저 는 4.65 버 전 을 다운 받 았 습 니 다.이 파일 이름 인 코딩 에 대한 지원 은 9.20 이 좋 지 않 습 니 다.중국어 에 문제 가 있 을 수 있 지만 제 요 구 는 중국어 파일 이름 을 지원 할 필요 가 없 기 때문에 충분히 사용 할 수 있 습 니 다.
압축 을 풀 고 7z 이 공 사 를 먼저 보 세 요.이 예 는 파일 압축 해제 작업 만 있 고 모방 하면 더욱 간단 한 압축 해제 함 수 를 쓸 수 있 습 니 다.
필요 한 파일 은 인 스 턴 스 를 참고 할 수 있 습 니 다.
7zMain.c 를 수정 하면 됩 니 다.
우리 의 목적 은 함수 extract7z 를 쓰 는 것 입 니 다.수신 매개 변 수 는 7z 파일 경로 이 고 출력 파일 경 로 는 모든 압축 을 풀 수 있 습 니 다.
주 호출 함수:
SRes SzArEx_Open(CSzArEx *p, ILookInStream *inStream, ISzAlloc *allocMain, ISzAlloc *allocTemp);
SRes SzAr_Extract(
const CSzArEx *p,
ILookInStream *inStream,
UInt32 fileIndex,
UInt32 *blockIndex,
Byte **outBuffer,
size_t *outBufferSize,
size_t *offset,
size_t *outSizeProcessed,
ISzAlloc *allocMain,
ISzAlloc *allocTemp);
우 리 는 먼저 Windows 에서 컴 파일 합 니 다:전체 코드 는 다음 과 같 습 니 다:
/* 7zMain.c - Test application for 7z Decoder
*/
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#define LOGD printf
#define LOGE printf
#include "7zCrc.h"
#include "7zFile.h"
#include "7zVersion.h"
#include "7zAlloc.h"
#include "7zExtract.h"
#include "7zIn.h"
int MY_CDECL extract7z(const char* srcFile, const char* dstPath)
{
CFileInStream archiveStream;
CLookToRead lookStream;
CSzArEx db;
SRes res;
ISzAlloc allocImp;
ISzAlloc allocTempImp;
char outPath[1024] = { 0 };
LOGD("7z ANSI-C Decoder " MY_VERSION_COPYRIGHT_DATE "
");
if (InFile_Open(&archiveStream.file, srcFile)) {//open 7z file
LOGE("can not open input file
");
return 1;
}
FileInStream_CreateVTable(&archiveStream);
LookToRead_CreateVTable(&lookStream, False);
lookStream.realStream = &archiveStream.s;
LookToRead_Init(&lookStream);
allocImp.Alloc = SzAlloc;
allocImp.Free = SzFree;
allocTempImp.Alloc = SzAllocTemp;
allocTempImp.Free = SzFreeTemp;
CrcGenerateTable();
SzArEx_Init(&db);
res = SzArEx_Open(&db, &lookStream.s, &allocImp, &allocTempImp);
if(res == SZ_OK)
{
Int32 i;
UInt32 blockIndex = 0xFFFFFFFF; /* it can have any value before first call (if outBuffer = 0) */
Byte *outBuffer = 0; /* it must be 0 before first call for each new archive. */
size_t outBufferSize = 0; /* it can have any value before first call (if outBuffer = 0) */
LOGD("Total file/directory count[%d]
", db.db.NumFiles);
for (i = db.db.NumFiles - 1; i >= 0; i--) {
size_t offset;
size_t outSizeProcessed;
CSzFileItem *f = db.db.Files + i;
strcpy(outPath, dstPath);
strcat(outPath, "/");
strcat(outPath, f->Name);
if (f->IsDir) { //dir
LOGD("dir [%s]
", outPath);
mkdir(outPath);
continue;
}else{ //file
LOGD("file [%s]
", outPath);
res = SzAr_Extract(&db, &lookStream.s, i, &blockIndex,
&outBuffer, &outBufferSize, &offset, &outSizeProcessed,
&allocImp, &allocTempImp);
if (res != SZ_OK){
break;
}else{
CSzFile outFile;
size_t processedSize;
if (OutFile_Open(&outFile, outPath)) {
LOGE("can not open output file
");
res = SZ_ERROR_FAIL;
break;
}
processedSize = outSizeProcessed;
if (File_Write(&outFile, outBuffer + offset, &processedSize)
!= 0 || processedSize != outSizeProcessed) {
LOGE("can not write output file
");
res = SZ_ERROR_FAIL;
break;
}
if (File_Close(&outFile)) {
LOGE("can not close output file
");
res = SZ_ERROR_FAIL;
break;
}
}
}
}
IAlloc_Free(&allocImp, outBuffer);
}
SzArEx_Free(&db, &allocImp);
File_Close(&archiveStream.file);
if (res == SZ_OK)
{
LOGD("Everything is Ok
");
return 0;
}
if (res == SZ_ERROR_UNSUPPORTED
)
LOGE("decoder doesn't support this archive
");
else if (res == SZ_ERROR_MEM
)
LOGE("can not allocate memory
");
else if (res == SZ_ERROR_CRC
)
LOGE("CRC error
");
else
LOGE("ERROR #%d
", res);
return 1;
}
int main(int numargs, char *args[])
{
return extract7z(args[1], args[2]);
}
저 는 Eclipse 를 사용 하고 Mingw 로 컴 파일 합 니 다.
실행 효 과 는 정확하게 스트레스 를 풀 수 있다.
이러한 압축 해 제 는 간단 한 압축 해제 만 적용 할 수 있 고 암호 화 는 지원 되 지 않 습 니 다.매개 변수 2 의 출력 파일 경로 에 있 는 모든 폴 더 가 존재 해 야 합 니 다.압축 패키지 에 있 는 폴 더 는 존재 하지 않 아 도 되 고 압축 해제 시 자동 으로 생 성 됩 니 다.
압축 된 가방 의 폴 더 는 중국어 로 할 수 없습니다.그렇지 않 으 면 어 지 럽 습 니 다.
MD5 알고리즘 을 사용 하여 파일 의 완전 성 이나 암호 의 정확성 을 검증 합 니 다.
MD5 즉 Message-Digest Algorithm 5(정보-요약 알고리즘 5)로 정보 전송 이 완전 하 게 일치 하도록 확보 합 니 다.컴퓨터 가 광범 위 하 게 사용 하 는 컴 퓨 팅 알고리즘 중 하나(요약 알고리즘,해시 알고리즘)로 주류 프로 그래 밍 언어 는 보편적으로 MD5 가 실현 되 었 다.
데이터(예 를 들 어 한자)를 다른 고정 길이 값 으로 연산 하 는 것 은 혼합 알고리즘 의 기초 원리 이 고 MD5 의 전신 은 MD2,MD3 와 MD4 가 있다.
MD5 의 역할 은 대 용량 정 보 를 디지털 서명 소프트웨어 로 개인 키 에 서명 하기 전에 비밀 형식 으로 압축 하 는 것 이다.
MD5 는 실제 응용 에서 보통 두 가지 용법 이 있 는데 하 나 는 문자열 의 MD5 값 을 계산 하 는 것 으로 암호 와 관련 된 작업 에 자주 사용 된다.다른 하 나 는 파일 의 MD5 값 을 계산 하 는 데 사용 되 며,일반적으로 네트워크 전송 에서 파일 의 오류 여 부 를 검증 하 는 데 사 용 됩 니 다.
다음은 C 언어의 MD5 컴 퓨 팅 프로그램 입 니 다.Stardict 에서 왔 습 니 다.인터넷 에서 유행 하 는 코드 는 모두 대동소이 합 니 다.
md5.h
#ifndef MD5_H
#define MD5_H
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#ifdef HAVE_STDINT_H
#include <stdint.h>
typedef uint32_t uint32;
#else
/* A.Leo.: this wont work on 16 bits platforms ;) */
typedef unsigned uint32;
#endif
#define MD5_FILE_BUFFER_LEN 1024
struct MD5Context {
uint32 buf[4];
uint32 bits[2];
unsigned char in[64];
};
void MD5Init(struct MD5Context *context);
void MD5Update(struct MD5Context *context, unsigned char const *buf,
unsigned len);
void MD5Final(unsigned char digest[16], struct MD5Context *context);
void MD5Transform(uint32 buf[4], uint32 const in[16]);
int getBytesMD5(const unsigned char* src, unsigned int length, char* md5);
int getStringMD5(const char* src, char* md5);
int getFileMD5(const char* path, char* md5);
/*
* This is needed to make RSAREF happy on some MS-DOS compilers.
*/
typedef struct MD5Context MD5_CTX;
#ifdef __cplusplus
}
#endif /* __cplusplus */
#endif /* !MD5_H */
원본 파일:md5.c
#include <string.h> /* for memcpy() */
#include <stdio.h>
#include "md5.h"
#ifndef HIGHFIRST
#define byteReverse(buf, len) /* Nothing */
#else
void byteReverse(unsigned char *buf, unsigned longs);
#ifndef ASM_MD5
/*
* Note: this code is harmless on little-endian machines.
*/
void byteReverse(unsigned char *buf, unsigned longs)
{
uint32 t;
do {
t = (uint32) ((unsigned) buf[3] << 8 | buf[2]) << 16 |
((unsigned) buf[1] << 8 | buf[0]);
*(uint32 *) buf = t;
buf += 4;
}while (--longs);
}
#endif
#endif
static void putu32(uint32 data, unsigned char *addr) {
addr[0] = (unsigned char) data;
addr[1] = (unsigned char) (data >> 8);
addr[2] = (unsigned char) (data >> 16);
addr[3] = (unsigned char) (data >> 24);
}
/*
* Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
* initialization constants.
*/
void MD5Init(struct MD5Context *ctx) {
ctx->buf[0] = 0x67452301;
ctx->buf[1] = 0xefcdab89;
ctx->buf[2] = 0x98badcfe;
ctx->buf[3] = 0x10325476;
ctx->bits[0] = 0;
ctx->bits[1] = 0;
}
/*
* Update context to reflect the concatenation of another buffer full
* of bytes.
*/
void MD5Update(struct MD5Context *ctx, unsigned char const *buf, unsigned len) {
uint32 t;
/* Update bitcount */
t = ctx->bits[0];
if ((ctx->bits[0] = t + ((uint32) len << 3)) < t)
ctx->bits[1]++; /* Carry from low to high */
ctx->bits[1] += len >> 29;
t = (t >> 3) & 0x3f; /* Bytes already in shsInfo->data */
/* Handle any leading odd-sized chunks */
if (t) {
unsigned char *p = (unsigned char *) ctx->in + t;
t = 64 - t;
if (len < t) {
memcpy(p, buf, len);
return;
}
memcpy(p, buf, t);
byteReverse(ctx->in, 16);
MD5Transform(ctx->buf, (uint32 *) ctx->in);
buf += t;
len -= t;
}
/* Process data in 64-byte chunks */
while (len >= 64) {
memcpy(ctx->in, buf, 64);
byteReverse(ctx->in, 16);
MD5Transform(ctx->buf, (uint32 *) ctx->in);
buf += 64;
len -= 64;
}
/* Handle any remaining bytes of data. */
memcpy(ctx->in, buf, len);
}
/*
* Final wrapup - pad to 64-byte boundary with the bit pattern
* 1 0* (64-bit count of bits processed, MSB-first)
*/
void MD5Final(unsigned char digest[16], struct MD5Context *ctx) {
unsigned count;
unsigned char *p;
/* Compute number of bytes mod 64 */
count = (ctx->bits[0] >> 3) & 0x3F;
/* Set the first char of padding to 0x80. This is safe since there is
always at least one byte free */
p = ctx->in + count;
*p++ = 0x80;
/* Bytes of padding needed to make 64 bytes */
count = 64 - 1 - count;
/* Pad out to 56 mod 64 */
if (count < 8) {
/* Two lots of padding: Pad the first block to 64 bytes */
memset(p, 0, count);
byteReverse(ctx->in, 16);
MD5Transform(ctx->buf, (uint32 *) ctx->in);
/* Now fill the next block with 56 bytes */
memset(ctx->in, 0, 56);
} else {
/* Pad block to 56 bytes */
memset(p, 0, count - 8);
} byteReverse(ctx->in, 14);
/* Append length in bits and transform */
//((uint32 *) ctx->in)[14] = ctx->bits[0];
//((uint32 *) ctx->in)[15] = ctx->bits[1];
putu32(ctx->bits[0], ctx->in + 56);
putu32(ctx->bits[1], ctx->in + 60);
MD5Transform(ctx->buf, (uint32 *) ctx->in);
byteReverse((unsigned char *) ctx->buf, 4);
memcpy(digest, ctx->buf, 16);
memset(ctx, 0, sizeof(*ctx)); /* In case it's sensitive */
}
#ifndef ASM_MD5
/* The four core functions - F1 is optimized somewhat */
/* #define F1(x, y, z) (x & y | ~x & z) */
#define F1(x, y, z) (z ^ (x & (y ^ z)))
#define F2(x, y, z) F1(z, x, y)
#define F3(x, y, z) (x ^ y ^ z)
#define F4(x, y, z) (y ^ (x | ~z))
/* This is the central step in the MD5 algorithm. */
#define MD5STEP(f, w, x, y, z, data, s) \
( w += f(x, y, z) + data, w = w<<s | w>>(32-s), w += x )
/*
* The core of the MD5 algorithm, this alters an existing MD5 hash to
* reflect the addition of 16 longwords of new data. MD5Update blocks
* the data and converts bytes into longwords for this routine.
*/
void MD5Transform(uint32 buf[4], uint32 const in[16]) {
register uint32 a, b, c, d;
a = buf[0];
b = buf[1];
c = buf[2];
d = buf[3];
MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
buf[0] += a;
buf[1] += b;
buf[2] += c;
buf[3] += d;
}
/*
* get MD5 of a byte buffer
*/
int getBytesMD5(const unsigned char* src, unsigned int length, char* md5) {
unsigned char i = 0;
unsigned char md5Bytes[16] = { 0 };
MD5_CTX context;
if (src == NULL || md5 == NULL)
{
return -1;
}
MD5Init(&context);
MD5Update(&context, src, length);
MD5Final(md5Bytes, &context);
for (i = 0; i < 16; i++) {
sprintf(md5, "%02X", md5Bytes[i]);
md5 += 2;
}
*md5 = '\0';
return 0;
}
/*
* get MD5 for a string
*/
int getStringMD5(const char* src, char* md5) {
return getBytesMD5((unsigned char*) src, strlen((char*) src), md5);
}
/**
* get MD5 of a file
*/
int getFileMD5(const char* path, char* md5) {
FILE* fp = NULL;
unsigned char buffer[MD5_FILE_BUFFER_LEN] = { 0 };
int count = 0;
MD5_CTX context;
unsigned char md5Bytes[16] = { 0 };
int i;
if (path == NULL || md5 == NULL) {
return -1;
}
fp = fopen(path, "rb");
if (fp == NULL) {
return -1;
}
MD5Init(&context);
while ((count = fread(buffer, 1, MD5_FILE_BUFFER_LEN, fp)) > 0) {
MD5Update(&context, buffer, count);
}
MD5Final(md5Bytes, &context);
for (i = 0; i < 16; i++) {
sprintf(md5, "%02X", md5Bytes[i]);
md5 += 2;
}
*md5 = '\0';
return 0;
}
#endif
다음은 호출 함수 로 MD5 를 계산 하 는 코드 입 니 다.main.c
#include <stdio.h>
#include <string.h>
#include "md5.h"
int main(int c, char** v){
char buffer[128];
getStringMD5("hello world", buffer);
printf("%s
", buffer);
getFileMD5("hello.pdf", buffer);
printf("%s
", buffer);
return 0;
}
계산 오류 없 음:이 내용에 흥미가 있습니까?
현재 기사가 여러분의 문제를 해결하지 못하는 경우 AI 엔진은 머신러닝 분석(스마트 모델이 방금 만들어져 부정확한 경우가 있을 수 있음)을 통해 가장 유사한 기사를 추천합니다:
C 언어 체인 시계는 뱀을 탐식하는 작은 게임을 실현한다본고의 실례는 여러분에게 C 언어 체인표가 뱀 탐식 게임을 실현하는 구체적인 코드를 공유하여 참고하도록 하였으며, 구체적인 내용은 다음과 같다. 프로젝트 이름: 뱀놀이 운영 환경: Linux 프로그래밍 언어: C 언...
텍스트를 자유롭게 공유하거나 복사할 수 있습니다.하지만 이 문서의 URL은 참조 URL로 남겨 두십시오.
CC BY-SA 2.5, CC BY-SA 3.0 및 CC BY-SA 4.0에 따라 라이센스가 부여됩니다.