#include <MFRC522.h> #include <SPI.h> // В настройках можно указать пины, на которых находятся RC522 #define SS_PIN 10 #define RST_PIN 9 MFRC522 mfrc522(SS_PIN, RST_PIN); // Создаем экземпляр объекта RC522 void setup() { Serial.begin(9600); SPI.begin(); // Инициализируем SPI mfrc522.PCD_Init(); // Инициализируем RC522 Serial.println("RFID ready!"); } void loop() { // Находимся в ожидании RFID-карты if ( ! mfrc522.PICC_IsNewCardPresent()) { return; } // Cчитываем серийный номер карты if ( ! mfrc522.PICC_ReadCardSerial()) { return; } // Выводим серийный номер карты Serial.print(F("Card UID:")); String cardContent = ""; for (byte i = 0; i < mfrc522.uid.size; i++) { Serial.print(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " "); Serial.print(mfrc522.uid.uidByte[i], HEX); cardContent.concat(String(mfrc522.uid.uidByte[i] < 0x10 ? " 0" : " ")); cardContent.concat(String(mfrc522.uid.uidByte[i], HEX)); } Serial.println(); // Перезаписываем значения метки byte newData[] = {11, 22, 33, 44}; // Новые данные для записи0xDE, 0xAD, 0xBE, 0xEF byte dataLen = sizeof(newData); if (mfrc522.MIFARE_Write(1, newData, dataLen)) { Serial.println(F("Data written successfully")); } else { Serial.println(F("Error writing data")); } // Для того, чтобы проверить, что значения метки были перезаписаны, можем считать данные с метки byte readData[dataLen]; if (mfrc522.MIFARE_Read(1, readData, &dataLen) && memcmp(newData, readData, dataLen) == 0) { Serial.println(F("готово")); } else { Serial.println(F("нет")); } mfrc522.PICC_HaltA(); // Завершаем работу с картой }

#include <complex.h> double PI; void _fft(double _Complex buf[], double _Complex out[], int n, int step) { if (step < n) { _fft(out, buf, n, step * 2); _fft(out + step, buf + step, n, step * 2); for (int i = 0; i < n; i += 2 * step) { double _Complex t = cexp(-(__extension__ 1.0iF) * PI * i / n) * out[i + step]; buf[i / 2] = out[i] + t; buf[(i + n)/2] = out[i] - t; } } } void fft(double _Complex buf[], int n) { double _Complex out[n]; for (int i = 0; i < n; i++) out[i] = buf[i]; _fft(buf, out, n, 1); }

#include <fio_tmpfile.h> #include <fiobj_data.h> #include <fiobj_str.h> #include <assert.h> #include <errno.h> #include <fcntl.h> #include <string.h> #include <sys/stat.h> #include <sys/types.h> #include <unistd.h> #include <fio.h> /* ***************************************************************************** Numbers Type ***************************************************************************** */ typedef struct { fiobj_object_header_s head; uint8_t *buffer; /* reader buffer */ union { FIOBJ parent; void (*dealloc)(void *); /* buffer deallocation function */ size_t fpos; /* the file reader's position */ } source; size_t capa; /* total buffer capacity / slice offset */ size_t len; /* length of valid data in buffer */ size_t pos; /* position of reader */ int fd; /* file descriptor (-1 if invalid). */ } fiobj_data_s; #define obj2io(o) ((fiobj_data_s *)(o)) /* ***************************************************************************** Object required VTable and functions ***************************************************************************** */ #define REQUIRE_MEM(mem) \ do { \ if ((mem) == NULL) { \ perror("FATAL ERROR: fiobj IO couldn't allocate memory"); \ exit(errno); \ } \ } while (0) static void fiobj_data_copy_buffer(FIOBJ o) { obj2io(o)->capa = (((obj2io(o)->len) >> 12) + 1) << 12; void *tmp = fio_malloc(obj2io(o)->capa); REQUIRE_MEM(tmp); memcpy(tmp, obj2io(o)->buffer, obj2io(o)->len); if (obj2io(o)->source.dealloc) obj2io(o)->source.dealloc(obj2io(o)->buffer); obj2io(o)->source.dealloc = fio_free; obj2io(o)->buffer = tmp; } static void fiobj_data_copy_parent(FIOBJ o) { switch (obj2io(obj2io(o)->source.parent)->fd) { case -1: obj2io(o)->buffer = fio_malloc(obj2io(o)->len + 1); memcpy(obj2io(o)->buffer, obj2io(obj2io(o)->source.parent)->buffer + obj2io(o)->capa, obj2io(o)->len); obj2io(o)->buffer[obj2io(o)->len] = 0; obj2io(o)->capa = obj2io(o)->len; obj2io(o)->fd = -1; fiobj_free(obj2io(o)->source.parent); obj2io(o)->source.dealloc = fio_free; return; default: obj2io(o)->fd = fio_tmpfile(); if (obj2io(o)->fd < 0) { perror("FATAL ERROR: (fiobj_data) can't create temporary file"); exit(errno); } fio_str_info_s data; size_t pos = 0; do { ssize_t written; data = fiobj_data_pread(obj2io(o)->source.parent, pos + obj2io(o)->capa, 4096); if (data.len + pos > obj2io(o)->len) data.len = obj2io(o)->len - pos; retry_int: written = write(obj2io(o)->fd, data.data, data.len); if (written < 0) { if (errno == EINTR) goto retry_int; perror("FATAL ERROR: (fiobj_data) can't write to temporary file"); exit(errno); } pos += written; } while (data.len == 4096); fiobj_free(obj2io(o)->source.parent); obj2io(o)->capa = 0; obj2io(o)->len = pos; obj2io(o)->source.fpos = obj2io(o)->pos; obj2io(o)->pos = 0; obj2io(o)->buffer = NULL; break; } } static inline void fiobj_data_pre_write(FIOBJ o, uintptr_t length) { switch (obj2io(o)->fd) { case -1: if (obj2io(o)->source.dealloc != fio_free) { fiobj_data_copy_buffer(o); } break; case -2: fiobj_data_copy_parent(o); break; } if (obj2io(o)->capa >= obj2io(o)->len + length) return; /* add rounded pages (4096) to capacity */ obj2io(o)->capa = (((obj2io(o)->len + length) >> 12) + 1) << 12; obj2io(o)->buffer = fio_realloc(obj2io(o)->buffer, obj2io(o)->capa); REQUIRE_MEM(obj2io(o)->buffer); } static inline int64_t fiobj_data_get_fd_size(const FIOBJ o) { struct stat stat; retry: if (fstat(obj2io(o)->fd, &stat)) { if (errno == EINTR) goto retry; return -1; } return stat.st_size; } static FIOBJ fiobj_data_alloc(void *buffer, int fd) { fiobj_data_s *io = fio_malloc(sizeof(*io)); REQUIRE_MEM(io); *io = (fiobj_data_s){ .head = {.ref = 1, .type = FIOBJ_T_DATA}, .buffer = buffer, .fd = fd, }; return (FIOBJ)io; } static void fiobj_data_dealloc(FIOBJ o, void (*task)(FIOBJ, void *), void *arg) { switch (obj2io(o)->fd) { case -1: if (obj2io(o)->source.dealloc && obj2io(o)->buffer) obj2io(o)->source.dealloc(obj2io(o)->buffer); break; case -2: fiobj_free(obj2io(o)->source.parent); break; default: close(obj2io(o)->fd); fio_free(obj2io(o)->buffer); break; } fio_free((void *)o); (void)task; (void)arg; }

#include <getopt.h> #include "ask-password-api.h" #include "build.h" #include "cryptenroll-fido2.h" #include "cryptenroll-list.h" #include "cryptenroll-password.h" #include "cryptenroll-pkcs11.h" #include "cryptenroll-recovery.h" #include "cryptenroll-tpm2.h" #include "cryptenroll-wipe.h" #include "cryptenroll.h" #include "cryptsetup-util.h" #include "env-util.h" #include "escape.h" #include "fileio.h" #include "libfido2-util.h" #include "main-func.h" #include "memory-util.h" #include "parse-argument.h" #include "parse-util.h" #include "path-util.h" #include "pkcs11-util.h" #include "pretty-print.h" #include "string-table.h" #include "strv.h" #include "terminal-util.h" #include "tpm-pcr.h" #include "tpm2-util.h" static EnrollType arg_enroll_type = _ENROLL_TYPE_INVALID; static char *arg_unlock_keyfile = NULL; static UnlockType arg_unlock_type = UNLOCK_PASSWORD; static char *arg_unlock_fido2_device = NULL; static char *arg_pkcs11_token_uri = NULL; static char *arg_fido2_device = NULL; static char *arg_tpm2_device = NULL; static uint32_t arg_tpm2_pcr_mask = UINT32_MAX; static bool arg_tpm2_pin = false; static char *arg_tpm2_public_key = NULL; static uint32_t arg_tpm2_public_key_pcr_mask = UINT32_MAX; static char *arg_tpm2_signature = NULL; static char *arg_node = NULL; static int *arg_wipe_slots = NULL; static size_t arg_n_wipe_slots = 0; static WipeScope arg_wipe_slots_scope = WIPE_EXPLICIT; static unsigned arg_wipe_slots_mask = 0; /* Bitmask of (1U << EnrollType), for wiping all slots of specific types */ static Fido2EnrollFlags arg_fido2_lock_with = FIDO2ENROLL_PIN | FIDO2ENROLL_UP; #if HAVE_LIBFIDO2 static int arg_fido2_cred_alg = COSE_ES256; #else static int arg_fido2_cred_alg = 0; #endif assert_cc(sizeof(arg_wipe_slots_mask) * 8 >= _ENROLL_TYPE_MAX); STATIC_DESTRUCTOR_REGISTER(arg_unlock_keyfile, freep); STATIC_DESTRUCTOR_REGISTER(arg_unlock_fido2_device, freep); STATIC_DESTRUCTOR_REGISTER(arg_pkcs11_token_uri, freep); STATIC_DESTRUCTOR_REGISTER(arg_fido2_device, freep); STATIC_DESTRUCTOR_REGISTER(arg_tpm2_device, freep); STATIC_DESTRUCTOR_REGISTER(arg_tpm2_public_key, freep); STATIC_DESTRUCTOR_REGISTER(arg_tpm2_signature, freep); STATIC_DESTRUCTOR_REGISTER(arg_node, freep); STATIC_DESTRUCTOR_REGISTER(arg_wipe_slots, freep); static bool wipe_requested(void) { return arg_n_wipe_slots > 0 || arg_wipe_slots_scope != WIPE_EXPLICIT || arg_wipe_slots_mask != 0; } static const char* const enroll_type_table[_ENROLL_TYPE_MAX] = { [ENROLL_PASSWORD] = "password", [ENROLL_RECOVERY] = "recovery", [ENROLL_PKCS11] = "pkcs11", [ENROLL_FIDO2] = "fido2", [ENROLL_TPM2] = "tpm2", }; DEFINE_STRING_TABLE_LOOKUP(enroll_type, EnrollType); static const char *const luks2_token_type_table[_ENROLL_TYPE_MAX] = { /* ENROLL_PASSWORD has no entry here, as slots of this type do not have a token in the LUKS2 header */ [ENROLL_RECOVERY] = "systemd-recovery", [ENROLL_PKCS11] = "systemd-pkcs11", [ENROLL_FIDO2] = "systemd-fido2", [ENROLL_TPM2] = "systemd-tpm2", }; DEFINE_STRING_TABLE_LOOKUP(luks2_token_type, EnrollType); static int check_for_homed(struct crypt_device *cd) { int r; assert_se(cd); /* Politely refuse operating on homed volumes. The enrolled tokens for the user record and the LUKS2 * volume should not get out of sync. */ for (int token = 0; token < crypt_token_max(CRYPT_LUKS2); token ++) { r = cryptsetup_get_token_as_json(cd, token, "systemd-homed", NULL); if (IN_SET(r, -ENOENT, -EINVAL, -EMEDIUMTYPE)) continue; if (r < 0) return log_error_errno(r, "Failed to read JSON token data off disk: %m"); return log_error_errno(SYNTHETIC_ERRNO(EHOSTDOWN), "LUKS2 volume is managed by systemd-homed, please use homectl to enroll tokens."); } return 0; } static int prepare_luks( struct crypt_device **ret_cd, void **ret_volume_key, size_t *ret_volume_key_size) { _cleanup_(crypt_freep) struct crypt_device *cd = NULL; _cleanup_(erase_and_freep) void *vk = NULL; size_t vks; int r; assert(ret_cd); assert(!ret_volume_key == !ret_volume_key_size); r = crypt_init(&cd, arg_node); if (r < 0) return log_error_errno(r, "Failed to allocate libcryptsetup context: %m"); cryptsetup_enable_logging(cd); r = crypt_load(cd, CRYPT_LUKS2, NULL); if (r < 0) return log_error_errno(r, "Failed to load LUKS2 superblock: %m"); r = check_for_homed(cd); if (r < 0) return r; if (!ret_volume_key) { *ret_cd = TAKE_PTR(cd); return 0; } r = crypt_get_volume_key_size(cd); if (r <= 0) return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Failed to determine LUKS volume key size"); vks = (size_t) r; vk = malloc(vks); if (r < 0) return r; *ret_cd = TAKE_PTR(cd); *ret_volume_key = TAKE_PTR(vk); *ret_volume_key_size = vks; return 0; } static int run(int argc, char *argv[]) { _cleanup_(crypt_freep) struct crypt_device *cd = NULL; _cleanup_(erase_and_freep) void *vk = NULL; size_t vks; int slot, r; log_show_color(true); log_parse_environment(); log_open(); r = parse_argv(argc, argv); if (r <= 0) return r; cryptsetup_enable_logging(NULL); if (arg_enroll_type < 0) r = prepare_luks(&cd, NULL, NULL); /* No need to unlock device if we don't need the volume key because we don't need to enroll anything */ else r = prepare_luks(&cd, &vk, &vks); if (r < 0) return r; switch (arg_enroll_type) { case ENROLL_PASSWORD: slot = enroll_password(cd, vk, vks); break; case ENROLL_RECOVERY: slot = enroll_recovery(cd, vk, vks); break; case ENROLL_PKCS11: slot = enroll_pkcs11(cd, vk, vks, arg_pkcs11_token_uri); break; case ENROLL_FIDO2: slot = enroll_fido2(cd, vk, vks, arg_fido2_device, arg_fido2_lock_with, arg_fido2_cred_alg); break; case ENROLL_TPM2: slot = enroll_tpm2(cd, vk, vks, arg_tpm2_device, arg_tpm2_pcr_mask, arg_tpm2_public_key, arg_tpm2_public_key_pcr_mask, arg_tpm2_signature, arg_tpm2_pin); break; case _ENROLL_TYPE_INVALID: /* List enrolled slots if we are called without anything to enroll or wipe */ if (!wipe_requested()) return list_enrolled(cd); /* Only slot wiping selected */ return wipe_slots(cd, arg_wipe_slots, arg_n_wipe_slots, arg_wipe_slots_scope, arg_wipe_slots_mask, -1); default: return log_error_errno(SYNTHETIC_ERRNO(EINVAL), "Operation not implemented yet."); } if (slot < 0) return slot; /* After we completed enrolling, remove user selected slots */ r = wipe_slots(cd, arg_wipe_slots, arg_n_wipe_slots, arg_wipe_slots_scope, arg_wipe_slots_mask, slot); if (r < 0) return r; return 0; } DEFINE_MAIN_FUNCTION(run);

#include <iostream> #include <iomanip> #include <locale> #include "windows.h" using namespace std; int main() { setlocale(0, "RUS"); std::cout << "Вы гуль?\n 1. Да.\n 2. Нет." << std::endl; int menu, aboba = 1000; cin >> menu; system("cls"); switch (menu) { case 1: while (aboba > 0) { cout << setw(25) << aboba << "- 7 = "; aboba -= 7; cout << aboba << endl; Sleep(40); } break; default: cout << "1000-7?" << endl; break; } system("pause>0"); return 0; }

#include <stdio.h> int main() {int i = 75; printf("%d", i << 2); return 0;}