From 75fb7278c993cbfdb442538e5a091b165502359d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Manuel=20V=C3=B6gele?= Date: Tue, 14 May 2019 13:27:11 +0200 Subject: [PATCH] Initial commit --- aes.cpp | 200 ++++++++++++++++++++++++++++++++++++++ aes.hpp | 41 ++++++++ break_script/break_aes.jl | 20 ++++ break_script/parse_csv.jl | 42 ++++++++ break_script/plotutils.jl | 14 +++ break_script/sbox.jl | 19 ++++ break_script/util.jl | 51 ++++++++++ main.cpp | 30 ++++++ meson.build | 7 ++ profiler.cpp | 16 +++ profiler.hpp | 20 ++++ 11 files changed, 460 insertions(+) create mode 100644 aes.cpp create mode 100644 aes.hpp create mode 100755 break_script/break_aes.jl create mode 100755 break_script/parse_csv.jl create mode 100644 break_script/plotutils.jl create mode 100644 break_script/sbox.jl create mode 100644 break_script/util.jl create mode 100644 main.cpp create mode 100644 meson.build create mode 100644 profiler.cpp create mode 100644 profiler.hpp diff --git a/aes.cpp b/aes.cpp new file mode 100644 index 0000000..7442c58 --- /dev/null +++ b/aes.cpp @@ -0,0 +1,200 @@ +#include "aes.hpp" + +#include +#include + +const FiniteFieldCalculator AES::ffcalc(0x11b); + +const uint8_t AES::sbox[256] = { + 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, + 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, + 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, + 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, + 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, + 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, + 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, + 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, + 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, + 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, + 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, + 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, + 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, + 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, + 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, + 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 }; + +const uint8_t AES::rsbox[256] = { + 0x52, 0x09, 0x6a, 0xd5, 0x30, 0x36, 0xa5, 0x38, 0xbf, 0x40, 0xa3, 0x9e, 0x81, 0xf3, 0xd7, 0xfb, + 0x7c, 0xe3, 0x39, 0x82, 0x9b, 0x2f, 0xff, 0x87, 0x34, 0x8e, 0x43, 0x44, 0xc4, 0xde, 0xe9, 0xcb, + 0x54, 0x7b, 0x94, 0x32, 0xa6, 0xc2, 0x23, 0x3d, 0xee, 0x4c, 0x95, 0x0b, 0x42, 0xfa, 0xc3, 0x4e, + 0x08, 0x2e, 0xa1, 0x66, 0x28, 0xd9, 0x24, 0xb2, 0x76, 0x5b, 0xa2, 0x49, 0x6d, 0x8b, 0xd1, 0x25, + 0x72, 0xf8, 0xf6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xd4, 0xa4, 0x5c, 0xcc, 0x5d, 0x65, 0xb6, 0x92, + 0x6c, 0x70, 0x48, 0x50, 0xfd, 0xed, 0xb9, 0xda, 0x5e, 0x15, 0x46, 0x57, 0xa7, 0x8d, 0x9d, 0x84, + 0x90, 0xd8, 0xab, 0x00, 0x8c, 0xbc, 0xd3, 0x0a, 0xf7, 0xe4, 0x58, 0x05, 0xb8, 0xb3, 0x45, 0x06, + 0xd0, 0x2c, 0x1e, 0x8f, 0xca, 0x3f, 0x0f, 0x02, 0xc1, 0xaf, 0xbd, 0x03, 0x01, 0x13, 0x8a, 0x6b, + 0x3a, 0x91, 0x11, 0x41, 0x4f, 0x67, 0xdc, 0xea, 0x97, 0xf2, 0xcf, 0xce, 0xf0, 0xb4, 0xe6, 0x73, + 0x96, 0xac, 0x74, 0x22, 0xe7, 0xad, 0x35, 0x85, 0xe2, 0xf9, 0x37, 0xe8, 0x1c, 0x75, 0xdf, 0x6e, + 0x47, 0xf1, 0x1a, 0x71, 0x1d, 0x29, 0xc5, 0x89, 0x6f, 0xb7, 0x62, 0x0e, 0xaa, 0x18, 0xbe, 0x1b, + 0xfc, 0x56, 0x3e, 0x4b, 0xc6, 0xd2, 0x79, 0x20, 0x9a, 0xdb, 0xc0, 0xfe, 0x78, 0xcd, 0x5a, 0xf4, + 0x1f, 0xdd, 0xa8, 0x33, 0x88, 0x07, 0xc7, 0x31, 0xb1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xec, 0x5f, + 0x60, 0x51, 0x7f, 0xa9, 0x19, 0xb5, 0x4a, 0x0d, 0x2d, 0xe5, 0x7a, 0x9f, 0x93, 0xc9, 0x9c, 0xef, + 0xa0, 0xe0, 0x3b, 0x4d, 0xae, 0x2a, 0xf5, 0xb0, 0xc8, 0xeb, 0xbb, 0x3c, 0x83, 0x53, 0x99, 0x61, + 0x17, 0x2b, 0x04, 0x7e, 0xba, 0x77, 0xd6, 0x26, 0xe1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0c, 0x7d }; + +const uint8_t AES::rc[10] = { + 0b00000001, + 0b00000010, + 0b00000100, + 0b00001000, + 0b00010000, + 0b00100000, + 0b01000000, + 0b10000000, + 0x1b, + 0x1b << 1 +}; + +void AES::print_data(uint8_t data[16]) +{ + for (int i = 0;i < 16;i++) + { + std::cout << std::hex << (int) data[i] << " "; + } + std::cout << std::endl; +} + +void AES::encrypt_ecb(uint8_t data[16], const uint8_t key[16]) +{ + uint8_t round_keys[11][16]; + construct_round_keys(key, round_keys); + add_round_key(data, round_keys[0]); + for (int r = 1;r < 10;r++) + { + sub_bytes(data); + shift_rows(data); + mix_columns(data); + add_round_key(data, round_keys[r]); + } + sub_bytes(data); + shift_rows(data); + add_round_key(data, round_keys[10]); +} + +void AES::add_round_key(uint8_t data_[16], const uint8_t key_[16]) +{ + const uint32_t (&key)[4] = *reinterpret_cast(key_); + uint32_t (&data)[4] = *reinterpret_cast(data_); + for (int i = 0;i < 4;i++) + { + data[i] ^= key[i]; + } +} + +void AES::sub_bytes(uint8_t data[16]) +{ + for (int i = 0;i < 16;i++) + { + data[i] = sbox[data[i]]; + } +} + +#define SWAP(x, y, tmp) tmp = x; x = y; y = tmp + +void AES::shift_rows(uint8_t data[16]) +{ + uint8_t tmp = data[1]; + data[1] = data[5]; + data[5] = data[9]; + data[9] = data[13]; + data[13] = tmp; + + SWAP(data[2], data[10], tmp); + SWAP(data[6], data[14], tmp); + + tmp = data[15]; + data[15] = data[11]; + data[11] = data[7]; + data[7] = data[3]; + data[3] = tmp; +} + +#undef SWAP + +void AES::mix_columns(uint8_t data[16]) +{ + uint8_t data_new[16]; + for (int i = 0;i < 4;i++) + { + data_new[i * 4 + 0] = ffcalc.mult2(data[i * 4 + 0]) ^ ffcalc.mult3(data[i * 4 + 1]) ^ data[i * 4 + 2] ^ data[i * 4 + 3]; + data_new[i * 4 + 1] = data[i * 4 + 0] ^ ffcalc.mult2(data[i * 4 + 1]) ^ ffcalc.mult3(data[i * 4 + 2]) ^ data[i * 4 + 3]; + data_new[i * 4 + 2] = data[i * 4 + 0] ^ data[i * 4 + 1] ^ ffcalc.mult2(data[i * 4 + 2]) ^ ffcalc.mult3(data[i * 4 + 3]); + data_new[i * 4 + 3] = ffcalc.mult3(data[i * 4 + 0]) ^ data[i * 4 + 1] ^ data[i * 4 + 2] ^ ffcalc.mult2(data[i * 4 + 3]); + } + memcpy(data, data_new, 16); +} + +void AES::construct_round_keys(const uint8_t initial_key_[16], uint8_t round_keys_[11][16]) +{ + const uint32_t (&initial_key)[4] = *reinterpret_cast(initial_key_); + uint32_t (&round_keys)[11][4] = *reinterpret_cast(round_keys_); + for (int k = 0;k < 4;k++) + { + round_keys[0][k] = initial_key[k]; + } + for (int r = 1;r < 11;r++) + { + round_keys[r][0] = round_keys[r - 1][0] ^ roundkey_g(round_keys[r - 1][3], r - 1); + round_keys[r][1] = round_keys[r][0] ^ round_keys[r - 1][1]; + round_keys[r][2] = round_keys[r][1] ^ round_keys[r - 1][2]; + round_keys[r][3] = round_keys[r][2] ^ round_keys[r - 1][3]; + } +} + +uint32_t AES::roundkey_g(uint32_t last_roundkey, uint8_t round) +{ + uint32_t result; + uint8_t *last = (uint8_t*) &last_roundkey; + uint8_t *next = (uint8_t*) &result; + next[3] = sbox[last[0]]; + next[0] = sbox[last[1]] ^ rc[round]; // TODO Check round + next[1] = sbox[last[2]]; + next[2] = sbox[last[3]]; + return result; +} + +FiniteFieldCalculator::FiniteFieldCalculator(uint16_t irreducible_polynomial) + : irreducible_polynomial(irreducible_polynomial) +{ + // Nothing to do +} + +uint16_t FiniteFieldCalculator::get_irreducible_polynomial() const +{ + return irreducible_polynomial; +} + +uint8_t FiniteFieldCalculator::reduce(uint16_t value) const +{ + return (uint8_t) add(value, get_irreducible_polynomial()); +} + +uint8_t FiniteFieldCalculator::mult2(uint8_t value) const +{ + uint16_t result = ((uint16_t) value) << 1; + if ((result & 0x100) == 0) + { + return (uint8_t) result; + } + else + { + for (int i = 0;i < 50;i++) + ; + return reduce(result); + } +} + +uint8_t FiniteFieldCalculator::mult3(uint8_t value) const +{ + uint8_t result = mult2(value); + return add(result, value); +} diff --git a/aes.hpp b/aes.hpp new file mode 100644 index 0000000..a900f11 --- /dev/null +++ b/aes.hpp @@ -0,0 +1,41 @@ +#ifndef AES_HPP_ +#define AES_HPP_ + +#include + +class FiniteFieldCalculator +{ +private: + uint16_t irreducible_polynomial; +public: + FiniteFieldCalculator(uint16_t irreducible_polynomial); + template + T add(T a, T b) const { + return a ^ b; + } + uint8_t mult2(uint8_t value) const; + uint8_t mult3(uint8_t value) const; + uint8_t reduce(uint16_t value) const; + uint16_t get_irreducible_polynomial() const; +}; + +class AES +{ +private: + static const uint8_t sbox[256]; + static const uint8_t rsbox[256]; + static const uint8_t rc[10]; + static const FiniteFieldCalculator ffcalc; +public: + AES(); + static void encrypt_ecb(uint8_t data[16], const uint8_t key[16]); + static void construct_round_keys(const uint8_t initial_key_[16], uint8_t round_keys_[11][16]); + static uint32_t roundkey_g(uint32_t last_roundkey, uint8_t round); + static void add_round_key(uint8_t data[16], const uint8_t key[16]); + static void shift_rows(uint8_t data[16]); + static void sub_bytes(uint8_t data[16]); + static void mix_columns(uint8_t data[16]); + static void print_data(uint8_t data[16]); +}; + +#endif diff --git a/break_script/break_aes.jl b/break_script/break_aes.jl new file mode 100755 index 0000000..7e69545 --- /dev/null +++ b/break_script/break_aes.jl @@ -0,0 +1,20 @@ +#!/usr/bin/env julia + +include("util.jl") +include("sbox.jl") +include("plotutils.jl") + +function break_aes() + plaintexts = load_file("plaintexts.dat", UInt8)[1:10_000, :] + timings = load_file("timings.dat", UInt32)[1:10_000] + t_values = Vector{Float64}(undef, 0x100) + for key=0:0xFF + msb_set = (sbox[(plaintexts[:, 1] .⊻ key) .+ 1] .& 0x80) .!= 0 + group_slow = timings[msb_set] + group_fast = timings[msb_set.==false] + t_values[key + 1] = t_val(group_fast, group_slow) + end + plot_discrete_tval(0:0xFF, t_values, "key") +end + +@time break_aes() diff --git a/break_script/parse_csv.jl b/break_script/parse_csv.jl new file mode 100755 index 0000000..f6e871a --- /dev/null +++ b/break_script/parse_csv.jl @@ -0,0 +1,42 @@ +#!/usr/bin/env julia + +import CSV +using Formatting + +function parse_csv(filename) + println("Starting parsing") + data = CSV.read(filename, header=0) + println("Parsing done") + plaintexts::Matrix{UInt8} = convert(Matrix{UInt8}, data[:, 1:16]) + timings::Matrix{UInt32} = convert(Matrix{UInt32}, data[:, 17:17]) + write_data("plaintexts.dat", plaintexts) + write_data("timings.dat", timings) +end + +function write_data(destination, data) + open(destination, "w") do file + field_size::UInt8 = sizeof(eltype(data)) + rows::UInt64 = size(data, 1) + cols::UInt64 = size(data, 2) + write(file, field_size); + write(file, rows) + write(file, cols) + write(file, data) + end +end + +function load_file(filename, type::Type{T})::Matrix{T} where T + open(filename, "r") do file + field_size = read(file, UInt8) + if field_size != sizeof(T) + throw(ArgumentError(format("Expected type of size {:d} but passed type '{}' has size {:d}", field_size, T, sizeof(T)))) + end + rows = read(file, UInt64) + cols = read(file, UInt64) + data = Matrix{T}(undef, rows, cols) + read!(file, data) + return data + end +end + +@time parse_csv("timing.csv") diff --git a/break_script/plotutils.jl b/break_script/plotutils.jl new file mode 100644 index 0000000..c5da446 --- /dev/null +++ b/break_script/plotutils.jl @@ -0,0 +1,14 @@ +#!/usr/bin/env julia + +using Plots + +function plot_discrete_tval(index, t_values, xlabel; size=(800, 533)) + t_plot = plot(index, t_values, legend=false, minorgrid=true, xlabel=xlabel, ylabel="t-value", size=size) + hline!(t_plot, [4.5]) + return t_plot +end + +function plot_power_measurements(index, t_values; size=(800, 533), color=:auto) + t_plot = plot(index, t_values, legend=false, minorgrid=true, xlabel="time", ylabel="power comsumption", size=size, color=color, linealpha=0.5, dpi=250) + return t_plot +end diff --git a/break_script/sbox.jl b/break_script/sbox.jl new file mode 100644 index 0000000..d1c5aa7 --- /dev/null +++ b/break_script/sbox.jl @@ -0,0 +1,19 @@ +#!/usr/bin/env julia + +const sbox = [ + 0x63, 0x7c, 0x77, 0x7b, 0xf2, 0x6b, 0x6f, 0xc5, 0x30, 0x01, 0x67, 0x2b, 0xfe, 0xd7, 0xab, 0x76, + 0xca, 0x82, 0xc9, 0x7d, 0xfa, 0x59, 0x47, 0xf0, 0xad, 0xd4, 0xa2, 0xaf, 0x9c, 0xa4, 0x72, 0xc0, + 0xb7, 0xfd, 0x93, 0x26, 0x36, 0x3f, 0xf7, 0xcc, 0x34, 0xa5, 0xe5, 0xf1, 0x71, 0xd8, 0x31, 0x15, + 0x04, 0xc7, 0x23, 0xc3, 0x18, 0x96, 0x05, 0x9a, 0x07, 0x12, 0x80, 0xe2, 0xeb, 0x27, 0xb2, 0x75, + 0x09, 0x83, 0x2c, 0x1a, 0x1b, 0x6e, 0x5a, 0xa0, 0x52, 0x3b, 0xd6, 0xb3, 0x29, 0xe3, 0x2f, 0x84, + 0x53, 0xd1, 0x00, 0xed, 0x20, 0xfc, 0xb1, 0x5b, 0x6a, 0xcb, 0xbe, 0x39, 0x4a, 0x4c, 0x58, 0xcf, + 0xd0, 0xef, 0xaa, 0xfb, 0x43, 0x4d, 0x33, 0x85, 0x45, 0xf9, 0x02, 0x7f, 0x50, 0x3c, 0x9f, 0xa8, + 0x51, 0xa3, 0x40, 0x8f, 0x92, 0x9d, 0x38, 0xf5, 0xbc, 0xb6, 0xda, 0x21, 0x10, 0xff, 0xf3, 0xd2, + 0xcd, 0x0c, 0x13, 0xec, 0x5f, 0x97, 0x44, 0x17, 0xc4, 0xa7, 0x7e, 0x3d, 0x64, 0x5d, 0x19, 0x73, + 0x60, 0x81, 0x4f, 0xdc, 0x22, 0x2a, 0x90, 0x88, 0x46, 0xee, 0xb8, 0x14, 0xde, 0x5e, 0x0b, 0xdb, + 0xe0, 0x32, 0x3a, 0x0a, 0x49, 0x06, 0x24, 0x5c, 0xc2, 0xd3, 0xac, 0x62, 0x91, 0x95, 0xe4, 0x79, + 0xe7, 0xc8, 0x37, 0x6d, 0x8d, 0xd5, 0x4e, 0xa9, 0x6c, 0x56, 0xf4, 0xea, 0x65, 0x7a, 0xae, 0x08, + 0xba, 0x78, 0x25, 0x2e, 0x1c, 0xa6, 0xb4, 0xc6, 0xe8, 0xdd, 0x74, 0x1f, 0x4b, 0xbd, 0x8b, 0x8a, + 0x70, 0x3e, 0xb5, 0x66, 0x48, 0x03, 0xf6, 0x0e, 0x61, 0x35, 0x57, 0xb9, 0x86, 0xc1, 0x1d, 0x9e, + 0xe1, 0xf8, 0x98, 0x11, 0x69, 0xd9, 0x8e, 0x94, 0x9b, 0x1e, 0x87, 0xe9, 0xce, 0x55, 0x28, 0xdf, + 0x8c, 0xa1, 0x89, 0x0d, 0xbf, 0xe6, 0x42, 0x68, 0x41, 0x99, 0x2d, 0x0f, 0xb0, 0x54, 0xbb, 0x16 ]; diff --git a/break_script/util.jl b/break_script/util.jl new file mode 100644 index 0000000..f68f4c5 --- /dev/null +++ b/break_script/util.jl @@ -0,0 +1,51 @@ +#!/usr/bin/env julia + +using Statistics + +function t_val(group_fast, group_slow) + if size(group_fast, 1) == 0 || size(group_slow, 1) == 0 + return 0 + end + mean_slow = mean(group_slow) + mean_fast = mean(group_fast) + s_slow = var(group_slow, mean=mean_slow) + s_fast = var(group_fast, mean=mean_fast) + return (mean_slow - mean_fast) / sqrt(s_slow / size(group_slow, 1) + s_fast / size(group_fast, 1)) +end + +function filter_peaks(data::Matrix{T})::Matrix{T} where T + m = mean(data, dims=2) + blocks = data .> m + blocks = hcat(.!blocks[:, 1], blocks) + is_edge = blocks[:, 1:end-1] .!= blocks[:, 2:end] + no_peaks = maximum([count(is_edge[row, :]) - 1 for row=1:size(data, 1)]) + peaks = zeros(T, size(data, 1), no_peaks) + @Threads.threads for row_no=1:size(data, 1) + row = data[row_no, :] + separators = findall(is_edge[row_no, :]) + for block_no=1:size(separators, 1)-1 + lsep, rsep = separators[block_no:block_no+1] + bm = mean(row[lsep:rsep]) + if bm > m[row_no] + peaks[row_no, block_no] = maximum(row[lsep:rsep]) + else + peaks[row_no, block_no] = minimum(row[lsep:rsep]) + end + end + end + return peaks +end + +function load_file(filename, type::Type{T})::Matrix{T} where T + open(filename, "r") do file + field_size = read(file, UInt8) + if field_size != sizeof(T) + throw(ArgumentError(format("Expected type of size {:d} but passed type '{}' has size {:d}", field_size, T, sizeof(T)))) + end + rows = read(file, UInt64) + cols = read(file, UInt64) + data = Matrix{T}(undef, rows, cols) + read!(file, data) + return data + end +end diff --git a/main.cpp b/main.cpp new file mode 100644 index 0000000..f1a05b9 --- /dev/null +++ b/main.cpp @@ -0,0 +1,30 @@ +#include "aes.hpp" + +#include +#include +#include +#include +#include + +using namespace std; +using namespace std::chrono; + +int main(int argc, char **argv) { + uint8_t data[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + const uint8_t key[16] = {0xA0,0x7C,0x3D,0x99,0xFA,0x00,0x02,0x46,0x97,0x33,0x73,0x50,0x31,0x7C,0xD3,0xDC}; + ifstream input("/dev/urandom", ios::binary); + for (int i = 0;i < 50000;i++) + { + input.read((char*) data, 16); + this_thread::sleep_for(nanoseconds(0)); + for (int d = 0;d < 16;d++) + { + cout << dec << (int) data[d] << ","; + } + auto start = high_resolution_clock::now(); + AES::encrypt_ecb(data, key); + auto stop = high_resolution_clock::now(); + cout << (stop - start).count() << endl; + } + return 0; +} diff --git a/meson.build b/meson.build new file mode 100644 index 0000000..7917ea0 --- /dev/null +++ b/meson.build @@ -0,0 +1,7 @@ +project('secutech', 'cpp') +executable('secutech', + 'main.cpp', + 'aes.cpp', + 'profiler.cpp', + ) + diff --git a/profiler.cpp b/profiler.cpp new file mode 100644 index 0000000..8da3ca3 --- /dev/null +++ b/profiler.cpp @@ -0,0 +1,16 @@ +#include "profiler.hpp" + +using std::string; + +Profiler profiler; + +void Profiler::record_function_call(char *function_name) +{ + calls[function_name]++; +} + +void Profiler::clear() +{ + calls.clear(); +} + diff --git a/profiler.hpp b/profiler.hpp new file mode 100644 index 0000000..480b718 --- /dev/null +++ b/profiler.hpp @@ -0,0 +1,20 @@ +#ifndef PROFILER_HPP_ +#define PROFILER_HPP_ + +#include +#include + +class Profiler +{ +public: + std::map calls; + void record_function_call(char *function_name); + void clear(); +}; + +//#define PROFILER_RECORD profiler.record_function_call((char*) __func__) +#define PROFILER_RECORD + +extern Profiler profiler; + +#endif