首页
社区
课程
招聘
问答 CTF 排行榜 知识库 工具下载 看雪峰会 看雪商城 证书查询
  1. 社区
  2. 编程技术
    3. 发新帖
[分享]关于RSA碰撞，发个代码
发表于: 2017-5-19 21:54 8983

[分享]关于RSA碰撞，发个代码

cvcvxk 活跃值
10
2017-5-19 21:54
8983

代码原作者是nooby，翻自己硬盘找到的——n年前的东西了

rsahunt可曾有人记得？代码直接贴了，大体上就是数学库gmp和mongdb操作库libmongoc

qq群：48715131 氪金会

#include <stdio.h>
#include <stdlib.h>
#include <gmp.h>
#include <libmongoc-1.0/mongoc.h>
#include <signal.h>
mpz_t pool;
char poolstr[256];
char tmp[50];
bson_error_t error;
bson_t query;
bson_t update;
bson_t child;
bson_t child2;
size_t count;
uint8_t* pbuf;
bson_t fields;
int pool_id = 0;
mongoc_collection_t* collection;
//#define CHECK_POOL
bool bExit = false;
void exit_save_pool(void)
{
	FILE* f = fopen(poolstr, "wb");
	mpz_out_raw(f, pool);
	fclose(f);
}
void handle_signal(int sig)
{
	bExit = true;
}
void strip_factor(mpz_ptr out, mpz_srcptr n, mpz_srcptr f)
{
	mpz_t t;
	mpz_init_set(t, f);
	while (mpz_cmp_ui(t, 1) > 0) {
		mpz_divexact(out, n, t);
		mpz_gcd(t, out, t);
	}
	mpz_clear(t);
}
int do_work(const bson_t* doc) {
	bson_iter_t iter;
	bson_iter_init_find(&iter, doc, "N");
	mpz_t n;
	mpz_init(n);
	const uint8_t* pData;
	uint32_t len;
	bson_iter_binary(&iter, NULL, &len, &pData);
	mpz_import(n, len, 1, sizeof(pData[0]), 0, 0, pData);
	bson_iter_init_find(&iter, doc, "_id");
	bson_iter_binary(&iter, NULL, &len, &pData);
	if (mpz_cmp_ui(n, 1) > 0) {
		mpz_t t;
		mpz_init(t);
		mpz_gcd(t, pool, n);
		if (mpz_cmp_ui(t, 1) > 0) {
			mpz_t addition;
			mpz_init_set_ui(addition, 1);
			mpz_t p;
			mpz_init(p);
			if (mpz_cmp(t, n) != 0) {
				mpz_set(p, t);
				mpz_divexact(addition, n, t);
				bson_init(&query);
				bson_append_int32(&query, "p", -1, pool_id);
				bson_append_null(&query, "result", -1);
				mongoc_cursor_t* cursor2 = mongoc_collection_find(collection, MONGOC_QUERY_NO_CURSOR_TIMEOUT, 0, 0, 0, &query, &fields, NULL);
				bson_destroy(&query);
				while (!mongoc_cursor_error(cursor2, &error) && mongoc_cursor_more(cursor2)) {
					if (mongoc_cursor_next(cursor2, &doc)) {
						bson_iter_init_find(&iter, doc, "N");
						mpz_t n2;
						mpz_init(n2);
						const uint8_t* pData2;
						uint32_t len2;
						bson_iter_binary(&iter, NULL, &len2, &pData2);
						mpz_import(n2, len2, 1, sizeof(pData2[0]), 0, 0, pData2);
						bson_iter_init_find(&iter, doc, "_id");
						bson_iter_binary(&iter, NULL, &len2, &pData2);
						mpz_gcd(t, n2, p);
						if (mpz_cmp_ui(t, 1) > 0) {
							mpz_divexact(t, n2, t);
							if (mpz_cmp_ui(t, 1) > 0) {
								bson_init(&query);
								bson_append_binary(&query, "_id", -1, BSON_SUBTYPE_BINARY, pData2, len2);
								bson_init(&update);
								bson_append_document_begin(&update, "$set", -1, &child);
								bson_append_array_begin(&child, "result", -1, &child2);
								pbuf = (uint8_t*)mpz_export(NULL, &count, 1, sizeof(uint8_t), 0, 0, p);
								bson_append_binary(&child2, "0", -1, BSON_SUBTYPE_BINARY, pbuf, count);
								free(pbuf);
								pbuf = (uint8_t*)mpz_export(NULL, &count, 1, sizeof(uint8_t), 0, 0, t);
								bson_append_binary(&child2, "1", -1, BSON_SUBTYPE_BINARY, pbuf, count);
								free(pbuf);
								bson_append_array_end(&child, &child2);
								bson_append_now_utc(&child, "tf", -1);
								bson_append_document_end(&update, &child);
								bson_append_document_begin(&update, "$unset", -1, &child);
								bson_append_null(&child, "tc", -1);
								bson_append_document_end(&update, &child);
								if (!mongoc_collection_update(collection, MONGOC_UPDATE_NONE, &query, &update, NULL, &error)) {
									fprintf(stderr, "Update Failure: %s\n", error.message);
									exit_save_pool();
									return EXIT_FAILURE;
								}
								bson_destroy(&query);
								bson_destroy(&update);
							}
						}
						mpz_clear(n2);
					}
				}
				mongoc_cursor_destroy(cursor2);
			}
			else {
				mpz_set(p, n);
				bson_init(&query);
				bson_append_int32(&query, "p", -1, pool_id);
				mongoc_cursor_t* cursor2 = mongoc_collection_find(collection, MONGOC_QUERY_NO_CURSOR_TIMEOUT, 0, 0, 0, &query, &fields, NULL);
				bson_destroy(&query);
				while (!mongoc_cursor_error(cursor2, &error) && mongoc_cursor_more(cursor2)) {
					if (mongoc_cursor_next(cursor2, &doc)) {
						bson_iter_init_find(&iter, doc, "N");
						mpz_t n2;
						mpz_init(n2);
						const uint8_t* pData2;
						uint32_t len2;
						bson_iter_binary(&iter, NULL, &len2, &pData2);
						mpz_import(n2, len2, 1, sizeof(pData2[0]), 0, 0, pData2);
						bson_iter_init_find(&iter, doc, "_id");
						bson_iter_binary(&iter, NULL, &len2, &pData2);
						mpz_gcd(t, n2, n);
						if (mpz_cmp_ui(t, 1) > 0) {
							if (!bson_iter_init_find(&iter, doc, "result") || BSON_ITER_HOLDS_NULL(&iter)) {
								mpz_divexact(p, n2, t);
								if (mpz_cmp_ui(p, 1) > 0) {
									bson_init(&query);
									bson_append_binary(&query, "_id", -1, BSON_SUBTYPE_BINARY, pData2, len2);
									bson_init(&update);
									bson_append_document_begin(&update, "$set", -1, &child);
									bson_append_array_begin(&child, "result", -1, &child2);
									pbuf = (uint8_t*)mpz_export(NULL, &count, 1, sizeof(uint8_t), 0, 0, p);
									bson_append_binary(&child2, "0", -1, BSON_SUBTYPE_BINARY, pbuf, count);
									free(pbuf);
									pbuf = (uint8_t*)mpz_export(NULL, &count, 1, sizeof(uint8_t), 0, 0, t);
									bson_append_binary(&child2, "1", -1, BSON_SUBTYPE_BINARY, pbuf, count);
									free(pbuf);
									bson_append_array_end(&child, &child2);
									bson_append_now_utc(&child, "tf", -1);
									bson_append_document_end(&update, &child);
									bson_append_document_begin(&update, "$unset", -1, &child);
									bson_append_null(&child, "tc", -1);
									bson_append_document_end(&update, &child);
									if (!mongoc_collection_update(collection, MONGOC_UPDATE_NONE, &query, &update, NULL, &error)) {
										fprintf(stderr, "Update Failure: %s\n", error.message);
										exit_save_pool();
										return EXIT_FAILURE;
									}
									bson_destroy(&query);
									bson_destroy(&update);
								}
							}
							if (mpz_cmp(t, n) != 0) {
								mpz_set(p, t);
							}
						}
						mpz_clear(n2);
					}
				}
				mongoc_cursor_destroy(cursor2);
			}
			if (mpz_cmp_ui(p, 1) > 0) {
				if (mpz_cmp_ui(addition, 1) == 0) {
					mpz_gcd(t, n, p);
					if (mpz_cmp_ui(t, 1) > 0) {
						mpz_divexact(t, n, p);
					}
				}
				else {
					mpz_set(t, addition);
				}
				if (mpz_cmp_ui(t, 1) > 0) {
					bson_init(&query);
					bson_append_binary(&query, "_id", -1, BSON_SUBTYPE_BINARY, pData, len);
					bson_append_null(&query, "p", -1);
					bson_append_null(&query, "result", -1);
					bson_init(&update);
					bson_append_document_begin(&update, "$set", -1, &child);
					bson_append_int32(&child, "p", -1, pool_id);
					bson_append_array_begin(&child, "result", -1, &child2);
					pbuf = (uint8_t*)mpz_export(NULL, &count, 1, sizeof(uint8_t), 0, 0, p);
					bson_append_binary(&child2, "0", -1, BSON_SUBTYPE_BINARY, pbuf, count);
					free(pbuf);
					pbuf = (uint8_t*)mpz_export(NULL, &count, 1, sizeof(uint8_t), 0, 0, t);
					bson_append_binary(&child2, "1", -1, BSON_SUBTYPE_BINARY, pbuf, count);
					free(pbuf);
					bson_append_array_end(&child, &child2);
					bson_append_now_utc(&child, "tf", -1);
					bson_append_document_end(&update, &child);
					bson_append_document_begin(&update, "$unset", -1, &child);
					bson_append_null(&child, "tc", -1);
					bson_append_document_end(&update, &child);
					bson_t doc2;
					if (!mongoc_collection_find_and_modify(collection, &query, NULL, &update, NULL, false, false, false, &doc2, &error)) {
						fprintf(stderr, "Update Failure: %s\n", error.message);
						exit_save_pool();
						return EXIT_FAILURE;
					}
					bson_destroy(&query);
					bson_destroy(&update);
					if (bson_iter_init_find(&iter, &doc2, "value") && !BSON_ITER_HOLDS_NULL(&iter)) {
						mpz_gcd(t, pool, n);
						strip_factor(n, n, t);
						strip_factor(pool, pool, t);
						mpz_mul(n, n, t);
						mpz_mul(pool, pool, n);
					}
					else {
						bson_init(&query);
						bson_append_binary(&query, "_id", -1, BSON_SUBTYPE_BINARY, pData, len);
						bson_append_null(&query, "result", -1);
						mongoc_cursor_t* cursor2 = mongoc_collection_find(collection, MONGOC_QUERY_NO_CURSOR_TIMEOUT, 0, 0, 0, &query, &fields, NULL);
						bson_destroy(&query);
						while (!mongoc_cursor_error(cursor2, &error) && mongoc_cursor_more(cursor2)) {
							if (mongoc_cursor_next(cursor2, &doc)) {
								bson_iter_init_find(&iter, doc, "p");
								int other_id = bson_iter_int32(&iter);
								bson_init(&query);
								bson_append_binary(&query, "_id", -1, BSON_SUBTYPE_BINARY, pData, len);
								bson_append_null(&query, "result", -1);
								bson_init(&update);
								bson_append_document_begin(&update, "$set", -1, &child);
								bson_append_int32(&child, "p", -1, pool_id);
								bson_append_array_begin(&child, "result", -1, &child2);
								pbuf = (uint8_t*)mpz_export(NULL, &count, 1, sizeof(uint8_t), 0, 0, p);
								bson_append_binary(&child2, "0", -1, BSON_SUBTYPE_BINARY, pbuf, count);
								free(pbuf);
								pbuf = (uint8_t*)mpz_export(NULL, &count, 1, sizeof(uint8_t), 0, 0, t);
								bson_append_binary(&child2, "1", -1, BSON_SUBTYPE_BINARY, pbuf, count);
								free(pbuf);
								bson_append_array_end(&child, &child2);
								bson_append_now_utc(&child, "tf", -1);
								char tmp2[50];
								sprintf(tmp2, "r%d", other_id);
								bson_append_bool(&child, tmp2, -1, true);
								bson_append_document_end(&update, &child);
								bson_append_document_begin(&update, "$unset", -1, &child);
								bson_append_null(&child, "tc", -1);
								bson_append_document_end(&update, &child);
								bson_t doc3;
								if (!mongoc_collection_find_and_modify(collection, &query, NULL, &update, NULL, false, false, false, &doc3, &error)) {
									fprintf(stderr, "Update Failure: %s\n", error.message);
									exit_save_pool();
									return EXIT_FAILURE;
								}
								bson_destroy(&query);
								bson_destroy(&update);
								if (bson_iter_init_find(&iter, &doc3, "value") && !BSON_ITER_HOLDS_NULL(&iter)) {
									mpz_gcd(t, pool, n);
									strip_factor(n, n, t);
									strip_factor(pool, pool, t);
									mpz_mul(n, n, t);
									mpz_mul(pool, pool, n);
								}
								bson_destroy(&doc3);
							}
						}
						mongoc_cursor_destroy(cursor2);
					}
					bson_destroy(&doc2);
				}
				else {
					bson_init(&query);
					bson_append_binary(&query, "_id", -1, BSON_SUBTYPE_BINARY, pData, len);
					bson_append_null(&query, "p", -1);
					bson_init(&update);
					bson_append_document_begin(&update, "$set", -1, &child);
					bson_append_int32(&child, "p", -1, pool_id);
					bson_append_now_utc(&child, "tc", -1);
					bson_append_document_end(&update, &child);
					bson_t doc2;
					if (!mongoc_collection_find_and_modify(collection, &query, NULL, &update, NULL, false, false, false, &doc2, &error)) {
						fprintf(stderr, "Update Failure: %s\n", error.message);
						exit_save_pool();
						return EXIT_FAILURE;
					}
					bson_destroy(&query);
					bson_destroy(&update);
					if (!bson_iter_init_find(&iter, &doc2, "value") || BSON_ITER_HOLDS_NULL(&iter)) {
						bson_init(&query);
						bson_append_binary(&query, "_id", -1, BSON_SUBTYPE_BINARY, pData, len);
						mongoc_cursor_t* cursor2 = mongoc_collection_find(collection, MONGOC_QUERY_NO_CURSOR_TIMEOUT, 0, 0, 0, &query, &fields, NULL);
						bson_destroy(&query);
						while (!mongoc_cursor_error(cursor2, &error) && mongoc_cursor_more(cursor2)) {
							if (mongoc_cursor_next(cursor2, &doc)) {
								bson_iter_init_find(&iter, doc, "p");
								int other_id = bson_iter_int32(&iter);
								bson_init(&query);
								bson_append_binary(&query, "_id", -1, BSON_SUBTYPE_BINARY, pData, len);
								bson_append_null(&query, "result", -1);
								bson_init(&update);
								bson_append_document_begin(&update, "$set", -1, &child);
								bson_append_int32(&child, "p", -1, pool_id);
								bson_append_now_utc(&child, "tc", -1);
								char tmp2[50];
								sprintf(tmp2, "r%d", other_id);
								bson_append_bool(&child, tmp2, -1, true);
								bson_append_document_end(&update, &child);
								bson_t doc3;
								if (!mongoc_collection_find_and_modify(collection, &query, NULL, &update, NULL, false, false, false, &doc3, &error)) {
									fprintf(stderr, "Update Failure: %s\n", error.message);
									exit_save_pool();
									return EXIT_FAILURE;
								}
								bson_destroy(&query);
								bson_destroy(&update);
								bson_destroy(&doc3);
							}
						}
						mongoc_cursor_destroy(cursor2);
					}
					strip_factor(pool, pool, n);
					mpz_mul(pool, pool, n);
					bson_destroy(&doc2);
				}
			}
			mpz_clear(p);
			mpz_clear(addition);
		}
		else if (mpz_size(pool) * sizeof(mp_limb_t) < 0x400 * 0x400 * 0x400) {
			bson_init(&query);
			bson_append_binary(&query, "_id", -1, BSON_SUBTYPE_BINARY, pData, len);
			bson_append_null(&query, "p", -1);
			bson_init(&update);
			bson_append_document_begin(&update, "$set", -1, &child);
			bson_append_int32(&child, "p", -1, pool_id);
			bson_append_now_utc(&child, "tc", -1);
			bson_append_document_end(&update, &child);
			bson_t doc2;
			if (!mongoc_collection_find_and_modify(collection, &query, NULL, &update, NULL, false, false, false, &doc2, &error)) {
				fprintf(stderr, "Update Failure: %s\n", error.message);
				exit_save_pool();
				return EXIT_FAILURE;
			}
			bson_destroy(&query);
			bson_destroy(&update);
			if (bson_iter_init_find(&iter, &doc2, "value") && !BSON_ITER_HOLDS_NULL(&iter)) {
				mpz_mul(pool, pool, n);
			}
			bson_destroy(&doc2);
		}
		mpz_clear(t);
	}
	else {
		bson_init(&query);
		bson_append_binary(&query, "_id", -1, BSON_SUBTYPE_BINARY, pData, len);
		bson_append_null(&query, "p", -1);
		bson_init(&update);
		bson_append_document_begin(&update, "$set", -1, &child);
		bson_append_int32(&child, "p", -1, pool_id);
		bson_append_now_utc(&child, "tc", -1);
		bson_append_document_end(&update, &child);
		bson_t doc2;
		if (!mongoc_collection_find_and_modify(collection, &query, NULL, &update, NULL, false, false, false, &doc2, &error)) {
			fprintf(stderr, "Update Failure: %s\n", error.message);
			exit_save_pool();
			return EXIT_FAILURE;
		}
		bson_destroy(&query);
		bson_destroy(&update);
		bson_destroy(&doc2);
	}
	bson_init(&query);
	bson_append_binary(&query, "_id", -1, BSON_SUBTYPE_BINARY, pData, len);
	bson_init(&update);
	bson_append_document_begin(&update, "$unset", -1, &child);
	bson_append_null(&child, tmp, -1);
	bson_append_null(&child, "pp", -1);
	bson_append_document_end(&update, &child);
	if (!mongoc_collection_update(collection, MONGOC_UPDATE_NONE, &query, &update, NULL, &error)) {
		fprintf(stderr, "Update Failure: %s\n", error.message);
		exit_save_pool();
		return EXIT_FAILURE;
	}
	bson_destroy(&query);
	bson_destroy(&update);
	mpz_clear(n);
	return 0;
}
int main(int argc, char* argv[])
{
	const char *uristr = "mongodb://127.0.0.1/";
	const char *db_name = "rsahunt";
	mongoc_init();
	if (argc > 1) {
		pool_id = atoi(argv[1]);
	}
	sprintf(poolstr, "pool_%d.rhp", pool_id);
	FILE* f = fopen(poolstr, "ab+");
	mpz_init(pool);
	mpz_inp_raw(pool, f);
	fclose(f);
	if (mpz_cmp_ui(pool, 0) == 0) {
		mpz_set_ui(pool, 1);
	}
	signal(SIGINT, handle_signal);
	signal(SIGTERM, handle_signal);
	if (argc > 2) {
		uristr = argv[2];
	}
	if (argc > 3) {
		db_name = argv[3];
	}
	mongoc_client_t* client = mongoc_client_new(uristr);
	if (!client) {
		fprintf(stderr, "Failed to parse URI.\n");
		exit_save_pool();
		return EXIT_FAILURE;
	}
	collection = mongoc_client_get_collection(client, db_name, "rsahunt");
	bson_init(&fields);
	bson_append_int32(&fields, "certs", -1, 0);
	mongoc_cursor_t* cursor;
	bool bWork;
	while (!bExit) {
		sprintf(tmp, "c%d", pool_id);
		bson_init(&query);
		bson_append_bool(&query, tmp, -1, true);
		bson_append_int32(&query, "p", -1, pool_id);
		cursor = mongoc_collection_find(collection, MONGOC_QUERY_NO_CURSOR_TIMEOUT, 0, 0, 0, &query, &fields, NULL);
		bson_destroy(&query);
		while (!bExit && !mongoc_cursor_error(cursor, &error) && mongoc_cursor_more(cursor)) {
			const bson_t *doc;
			if (mongoc_cursor_next(cursor, &doc)) {
				bson_iter_t iter;
				bson_iter_init_find(&iter, doc, "N");
				mpz_t n;
				mpz_init(n);
				const uint8_t* pData;
				uint32_t len;
				bson_iter_binary(&iter, NULL, &len, &pData);
				mpz_import(n, len, 1, sizeof(pData[0]), 0, 0, pData);
				bson_iter_init_find(&iter, doc, "_id");
				bson_iter_binary(&iter, NULL, &len, &pData);
				if (mpz_cmp_ui(n, 1) > 0) {
					mpz_t t;
					mpz_init(t);
					mpz_gcd(t, pool, n);
					strip_factor(n, n, t);
					strip_factor(pool, pool, t);
					mpz_mul(n, n, t);
					mpz_mul(pool, pool, n);
					mpz_clear(t);
				}
				bson_init(&query);
				bson_append_binary(&query, "_id", -1, BSON_SUBTYPE_BINARY, pData, len);
				bson_init(&update);
				bson_append_document_begin(&update, "$unset", -1, &child);
				bson_append_null(&child, tmp, -1);
				bson_append_document_end(&update, &child);
				if (!mongoc_collection_update(collection, MONGOC_UPDATE_NONE, &query, &update, NULL, &error)) {
					fprintf(stderr, "Update Failure: %s\n", error.message);
					exit_save_pool();
					return EXIT_FAILURE;
				}
				bson_destroy(&query);
				bson_destroy(&update);
				mpz_clear(n);
			}
		}
		if (mongoc_cursor_error(cursor, &error)) {
			fprintf(stderr, "Cursor Failure: %s\n", error.message);
			exit_save_pool();
			return EXIT_FAILURE;
		}
		mongoc_cursor_destroy(cursor);
		if (!bExit) {
			sprintf(tmp, "r%d", pool_id);
			bson_init(&query);
			bson_append_bool(&query, tmp, -1, true);
			cursor = mongoc_collection_find(collection, MONGOC_QUERY_NO_CURSOR_TIMEOUT, 0, 0, 0, &query, &fields, NULL);
			bson_destroy(&query);
			while (!bExit && !mongoc_cursor_error(cursor, &error) && mongoc_cursor_more(cursor)) {
				const bson_t *doc;
				if (mongoc_cursor_next(cursor, &doc)) {
					bson_iter_t iter;
					bson_iter_init_find(&iter, doc, "N");
					mpz_t n;
					mpz_init(n);
					const uint8_t* pData;
					uint32_t len;
					bson_iter_binary(&iter, NULL, &len, &pData);
					mpz_import(n, len, 1, sizeof(pData[0]), 0, 0, pData);
					bson_iter_init_find(&iter, doc, "_id");
					bson_iter_binary(&iter, NULL, &len, &pData);
					if (mpz_cmp_ui(n, 1) > 0) {
						mpz_t t;
						mpz_init(t);
						mpz_gcd(t, pool, n);
						strip_factor(pool, pool, t);
						bson_init(&query);
						bson_append_document_begin(&query, "tf", -1, &child);
						bson_append_bool(&child, "$exists", -1, true);
						bson_append_document_end(&query, &child);
						bson_append_int32(&query, "p", -1, pool_id);
						mongoc_cursor_t* cursor2 = mongoc_collection_find(collection, MONGOC_QUERY_NO_CURSOR_TIMEOUT, 0, 0, 0, &query, &fields, NULL);
						bson_destroy(&query);
						while (!mongoc_cursor_error(cursor2, &error) && mongoc_cursor_more(cursor2)) {
							if (mongoc_cursor_next(cursor2, &doc)) {
								bson_iter_init_find(&iter, doc, "N");
								mpz_t n2;
								mpz_init(n2);
								const uint8_t* pData2;
								uint32_t len2;
								bson_iter_binary(&iter, NULL, &len2, &pData2);
								mpz_import(n2, len2, 1, sizeof(pData2[0]), 0, 0, pData2);
								mpz_gcd(t, pool, n2);
								strip_factor(n2, n2, t);
								strip_factor(pool, pool, t);
								mpz_mul(n2, n2, t);
								mpz_mul(pool, pool, n2);
								mpz_clear(n2);
							}
						}
						if (mongoc_cursor_error(cursor2, &error)) {
							fprintf(stderr, "Cursor Failure: %s\n", error.message);
							exit_save_pool();
							return EXIT_FAILURE;
						}
						mongoc_cursor_destroy(cursor2);
						mpz_clear(t);
					}
					mpz_clear(n);
					bson_init(&query);
					bson_append_binary(&query, "_id", -1, BSON_SUBTYPE_BINARY, pData, len);
					bson_init(&update);
					bson_append_document_begin(&update, "$unset", -1, &child);
					bson_append_null(&child, tmp, -1);
					bson_append_document_end(&update, &child);
					if (!mongoc_collection_update(collection, MONGOC_UPDATE_NONE, &query, &update, NULL, &error)) {
						fprintf(stderr, "Update Failure: %s\n", error.message);
						exit_save_pool();
						return EXIT_FAILURE;
					}
					bson_destroy(&query);
					bson_destroy(&update);
				}
			}
			if (mongoc_cursor_error(cursor, &error)) {
				fprintf(stderr, "Cursor Failure: %s\n", error.message);
				exit_save_pool();
				return EXIT_FAILURE;
			}
			mongoc_cursor_destroy(cursor);
		}
#if defined(CHECK_POOL)
		if (!bExit) {
			int count = 0;
			mpz_t ref_pool;
			mpz_init_set_ui(ref_pool, 1);
			bson_init(&query);
			bson_append_int32(&query, "p", -1, pool_id);
			cursor = mongoc_collection_find(collection, MONGOC_QUERY_NO_CURSOR_TIMEOUT, 0, 0, 0, &query, &fields, NULL);
			bson_destroy(&query);
			while (!mongoc_cursor_error(cursor, &error) && mongoc_cursor_more(cursor)) {
				const bson_t *doc;
				if (mongoc_cursor_next(cursor, &doc)) {
					bson_iter_t iter;
					bson_iter_init_find(&iter, doc, "N");
					mpz_t n;
					mpz_init(n);
					const uint8_t* pData;
					uint32_t len;
					bson_iter_binary(&iter, NULL, &len, &pData);
					mpz_import(n, len, 1, sizeof(pData[0]), 0, 0, pData);
					mpz_t t;
					mpz_init(t);
					mpz_gcd(t, ref_pool, n);
					strip_factor(n, n, t);
					strip_factor(ref_pool, ref_pool, t);
					mpz_mul(n, n, t);
					mpz_mul(ref_pool, ref_pool, n);
					mpz_clear(t);
					mpz_clear(n);
					if ((++count % 0x1000) == 0) {
						printf("%d\n", count);
					}
				}
			}
			if (mongoc_cursor_error(cursor, &error)) {
				fprintf(stderr, "Cursor Failure: %s\n", error.message);
				exit_save_pool();
				return EXIT_FAILURE;
			}
			mongoc_cursor_destroy(cursor);
			//mpz_set(pool, ref_pool);
			//return 0;
			int res = mpz_cmp(pool, ref_pool);
			if (res > 0) {
				printf("pool is not optimal\n");
			}
			else if (res < 0) {
				printf("pool error\n");
			}
			else
			{
				printf("pool is optimal\n");
			}
			mpz_clear(ref_pool);
			exit_save_pool();
			return 0;
		}
#endif
		if (!bExit) {
			bWork = false;
			sprintf(tmp, "c%d", pool_id);
			bson_init(&query);
			bson_append_int32(&query, "pp", -1, pool_id);
			bson_append_bool(&query, tmp, -1, true);
			bson_append_document_begin(&query, "p", -1, &child);
			bson_append_int32(&child, "$ne", -1, pool_id);
			bson_append_document_end(&query, &child);
			bson_append_null(&query, "result", -1);
			cursor = mongoc_collection_find(collection, MONGOC_QUERY_NO_CURSOR_TIMEOUT, 0, 0x1000, 0, &query, &fields, NULL);
			bson_destroy(&query);
			while (!bExit && !mongoc_cursor_error(cursor, &error) && mongoc_cursor_more(cursor)) {
				const bson_t *doc;
				if (mongoc_cursor_next(cursor, &doc)) {
					bWork = true;
					if (do_work(doc) != 0) {
						return EXIT_FAILURE;
					}
				}
			}
			if (mongoc_cursor_error(cursor, &error)) {
				fprintf(stderr, "Cursor Failure: %s\n", error.message);
				exit_save_pool();
				return EXIT_FAILURE;
			}
			mongoc_cursor_destroy(cursor);
		}
		if (!bExit && !bWork) {
			sprintf(tmp, "c%d", pool_id);
			bson_init(&query);
			bson_append_bool(&query, tmp, -1, true);
			bson_append_document_begin(&query, "p", -1, &child);
			bson_append_int32(&child, "$ne", -1, pool_id);
			bson_append_document_end(&query, &child);
			bson_append_null(&query, "result", -1);
			cursor = mongoc_collection_find(collection, MONGOC_QUERY_NO_CURSOR_TIMEOUT, 0, 0x1000, 0, &query, &fields, NULL);
			bson_destroy(&query);
			while (!bExit && !mongoc_cursor_error(cursor, &error) && mongoc_cursor_more(cursor)) {
				const bson_t *doc;
				if (mongoc_cursor_next(cursor, &doc)) {
					bWork = true;
					if (do_work(doc) != 0) {
						return EXIT_FAILURE;
					}
				}
			}
			if (mongoc_cursor_error(cursor, &error)) {
				fprintf(stderr, "Cursor Failure: %s\n", error.message);
				exit_save_pool();
				return EXIT_FAILURE;
			}
			mongoc_cursor_destroy(cursor);
			if (!bWork) {
				sleep(5);
			}
		}
	}
	bson_destroy(&fields);
	mongoc_collection_destroy(collection);
	mongoc_client_destroy(client);
	exit_save_pool();
	return 0;
}


[课程]Android-CTF解题方法汇总！

收藏
免费 ・1
支持
分享
最新回复 (20)
gmhzxy
雪    币： 284
活跃值： (250)
能力值： ( LV4，RANK：40 )
在线值：
发帖
回帖
粉丝
私信
2 楼
666666666666666666666666666666
2017-5-19 21:57
0
空白即是正义
雪    币： 2347
活跃值： (58)
能力值： ( LV2，RANK：10 )
在线值：
发帖
回帖
粉丝
私信
3 楼
无限增x~six  six  six
2017-5-19 22:05
0
地狱怪客
雪    币： 341
活跃值： (138)
能力值： ( LV7，RANK：110 )
在线值：
发帖
回帖
粉丝
私信
4 楼
厉害
2017-5-19 22:23
0
atompure
雪    币： 20557
活跃值： (3780)
能力值： ( LV3，RANK：20 )
在线值：
发帖
回帖
粉丝
私信
5 楼
点个赞，谢谢分享。
2017-5-20 04:47
0
ugvjewxf
雪    币： 615
活跃值： (530)
能力值： ( LV4，RANK：40 )
在线值：
发帖
回帖
粉丝
私信
6 楼
这玩意没数学基础，看不懂呀，
2017-5-20 07:22
0
fengyunabc
雪    币： 3700
活跃值： (3817)
能力值： ( LV4，RANK：50 )
在线值：
发帖
回帖
粉丝
私信
7 楼
感谢老V分享！
2017-5-20 12:36
0
EvCoX
雪    币： 59
活跃值： (1301)
能力值： ( LV3，RANK：30 )
在线值：
发帖
回帖
粉丝
私信
8 楼
感谢老V
2017-5-20 18:44
0
Howsk
雪    币： 207
活跃值： (58)
能力值： ( LV2，RANK：10 )
在线值：
发帖
回帖
粉丝
私信
9 楼
V叔发的东西总是这么深不可测。
2017-5-20 18:54
0
carllon
雪    币： 279
活跃值： (329)
能力值： ( LV2，RANK：10 )
在线值：
发帖
回帖
粉丝
私信
10 楼
老V又放大招了
2017-5-21 12:21
0
岭南散人
雪    币： 334
活跃值： (92)
能力值： ( LV7，RANK：100 )
在线值：
发帖
回帖
粉丝
私信
11 楼
2017-5-23 07:31
0
DegerYang
雪    币： 346
活跃值： (45)
能力值： ( LV3，RANK：20 )
在线值：
发帖
回帖
粉丝
私信
12 楼
神奇的硬盘  除了3/4的AV剩下的就是代码了！  求那1/4的内容！！！！
2017-5-23 09:04
0
ChengQing
雪    币： 573
活跃值： (979)
能力值： ( LV3，RANK：20 )
在线值：
发帖
回帖
粉丝
私信
13 楼
看不懂，但知道是好东西。收藏放硬盘里当传家宝
2017-5-23 13:21
0
wyfe
雪    币： 2575
活跃值： (487)
能力值： ( LV2，RANK：85 )
在线值：
发帖
回帖
粉丝
私信
14 楼
好东西的
2017-5-25 15:35
0
木志本柯
雪    币： 4662
活跃值： (3887)
能力值： ( LV2，RANK：10 )
在线值：
发帖
回帖
粉丝
私信
15 楼
一脸懵
2017-5-25 17:26
0
m马s
雪    币： 179
活跃值： (10)
能力值： ( LV2，RANK：10 )
在线值：
发帖
回帖
粉丝
私信
16 楼
M
2017-8-23 10:02
0
baggiowy
雪    币： 219
活跃值： (17)
能力值： ( LV2，RANK：10 )
在线值：
发帖
回帖
粉丝
私信
17 楼
好厉害！学习之
2017-8-30 23:48
0
杨开银
雪    币： 9
活跃值： (319)
能力值： ( LV2，RANK：10 )
在线值：
发帖
回帖
粉丝
私信
19 楼
因式分解源码呢，vv
2018-4-28 10:55
0
cvcvxk
雪    币： 8865
活跃值： (2379)
能力值： ( LV12，RANK：760 )
在线值：
发帖
回帖
粉丝
私信
20 楼
杨开银 因式分解源码呢，vv
不分解啊，这是碰撞啊，速度比分解快
2018-4-28 12:24
0
大大薇薇
雪    币： 1887
活跃值： (2731)
能力值： ( LV7，RANK：100 )
在线值：
发帖
回帖
粉丝
私信
21 楼
MD5碰撞，SHA1碰撞还能略懂。RSA碰撞？这是啥东西？
2018-4-28 12:42
0
杨开银
雪    币： 9
活跃值： (319)
能力值： ( LV2，RANK：10 )
在线值：
发帖
回帖
粉丝
私信
22 楼
cvcvxk 不分解啊，这是碰撞啊，速度比分解快
先存起来，搞完其他的回头看看，呵呵
2018-4-28 13:40
0
游客
登录 | 注册 方可回帖
回帖 表情 雪币赚取及消费
高级回复
返回
//