ynkmr/Sourcetrail
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

build,logic : Key/License Generator

Browse Source 
Generator using the Botan Cyrptography library
This commit is contained in:
Andreas Stallinger
2016-01-18 11:42:31 +01:00
committed by Eberhard Graether
parent 743f91e882
commit 23257a3071
31 changed files with 1260 additions and 21 deletions
Download Patch File Download Diff File Expand all files Collapse all files
.gitignore
+4
View File
@@ -25,9 +25,12 @@
.DS_Store
.idea
/ide_plugins/vs/vs2012/CoatiPlugin/CoatiPlugin/bin
/ide_plugins/vs/vs2012/CoatiPlugin/CoatiPlugin/obj
.clang_complete
*.coatidb
/deployment/windows/CoatiSetup/CoatiSetup/Debug
@@ -48,5 +51,6 @@
/deployment/windows/CoatiSetup/SetupRemoveCacheFiles/obj/
*.sqlite
*.pch
*.swp
.clang_complete
CMakeLists.txt
+95 -9
View File
@@ -44,9 +44,9 @@ project(${PROJECT_NAME})
if (UNIX)
if ("${CMAKE_BUILD_TYPE}" STREQUAL "Release")
find_package(LLVM REQUIRED PATHS "$ENV{CLANG_DIR}/build_release/share/llvm/cmake")
find_package(LLVM REQUIRED PATHS "$ENV{CLANG_DIR}/build_release/share/llvm/cmake" NO_DEFAULT_PATH)
else()
find_package(LLVM REQUIRED PATHS "$ENV{CLANG_DIR}/build_debug/share/llvm/cmake")
find_package(LLVM REQUIRED PATHS "$ENV{CLANG_DIR}/build_debug/share/llvm/cmake" NO_DEFAULT_PATH)
endif()
else()
find_package(LLVM REQUIRED PATHS "$ENV{CLANG_DIR}/build/share/llvm/cmake")
@@ -72,6 +72,38 @@ find_package(Boost 1.59 COMPONENTS system filesystem date_time REQUIRED)
add_definitions(-DEIGEN_MPL2_ONLY)
set(EIGEN_ROOT $ENV{EIGEN_DIR})
# Botan -------------------------------------------------------------------------
include(cmake/BotanConfig.cmake)
set(BOTAN_ROOT ${BOTAN_DIR})
FIND_PACKAGE ( Threads REQUIRED )
add_library(BOTAN STATIC ${BOTAN_ROOT}/botan_all.cpp)
target_link_libraries(BOTAN ${CMAKE_THREAD_LIBS_INIT})
target_compile_options(BOTAN PUBLIC "-pthread")
set_property(
TARGET BOTAN
PROPERTY INCLUDE_DIRECTORIES
"${BOTAN_ROOT}"
)
# set(BOTAN_MODULES "base,ecdsa,emsa1,passhash9,rng,rsa,egd,emsa_pssr,emsa_pkcs1,x509,aes,dev_random")
# ExternalProject_Add(BOTAN
# PREFIX $ENV{COATI_DEPEND_DIR}/botan
# GIT_REPOSITORY https://github.com/randombit/botan.git/
# GIT_TAG 1.11.23
# CONFIGURE_COMMAND ./configure.py --gen-amalgamation --minimized-build --enable-modules=${BOTAN_MODULES}
# )
# license/key generator and license class include
add_subdirectory(src/gen)
# Lib --------------------------------------------------------------------------
set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin/lib)
@@ -108,6 +140,7 @@ target_include_directories(${LIB_PROJECT_NAME} SYSTEM
${Boost_INCLUDE_DIRS}
${EIGEN_ROOT}
"${CMAKE_SOURCE_DIR}/src/external"
"${BOTAN_ROOT}"
)
target_link_libraries(${LIB_PROJECT_NAME} ${Boost_LIBRARIES})
@@ -246,7 +279,8 @@ if (WIN32)
"// remains consistent on all systems.\n"
"IDI_ICON1 ICON \"${CMAKE_SOURCE_DIR}/build/coati.ico\"\n"
)
add_executable(${APP_PROJECT_NAME} ${APP_FILES} ${CMAKE_SOURCE_DIR}/build/Coati.rc)
add_executable(${APP_PROJECT_NAME} ${APP_FILES} ${CLANG_FILES} ${GEN_FILES} ${CMAKE_SOURCE_DIR}/build/Coati.rc ${CMAKE_SOURCE_DIR}/build/src/app/version.h)
# hide the console when running a release build.
set_target_properties(${APP_PROJECT_NAME} PROPERTIES LINK_FLAGS_DEBUG "/SUBSYSTEM:CONSOLE")
@@ -255,14 +289,13 @@ if (WIN32)
set_target_properties(${APP_PROJECT_NAME} PROPERTIES COMPILE_DEFINITIONS_RELWITHDEBINFO "_CONSOLE")
set_target_properties(${APP_PROJECT_NAME} PROPERTIES LINK_FLAGS_RELEASE "/ENTRY:\"mainCRTStartup\" /SUBSYSTEM:WINDOWS")
set_target_properties(${APP_PROJECT_NAME} PROPERTIES LINK_FLAGS_MINSIZEREL "/SUBSYSTEM:WINDOWS")
else ()
add_executable(${APP_PROJECT_NAME} ${APP_FILES})
add_executable(${APP_PROJECT_NAME} ${APP_FILES} ${GEN_FILES} ${CMAKE_SOURCE_DIR}/build/src/app/version.h)
endif ()
create_source_groups(${APP_FILES})
target_link_libraries(${APP_PROJECT_NAME} ${LIB_GUI_PROJECT_NAME} ${LIB_PARSER_PROJECT_NAME} ${LIB_PROJECT_NAME} )
target_link_libraries(${APP_PROJECT_NAME} ${LIB_GUI_PROJECT_NAME} ${LIB_PARSER_PROJECT_NAME} ${LIB_PROJECT_NAME} BOTAN)
set_property(
TARGET ${APP_PROJECT_NAME}
@@ -272,6 +305,9 @@ set_property(
"${CMAKE_SOURCE_DIR}/src/lib_gui"
"${CMAKE_SOURCE_DIR}/src/lib_parser"
"${CMAKE_SOURCE_DIR}/build/src/lib_gui"
"${CMAKE_SOURCE_DIR}/src/gen"
"${CMAKE_SOURCE_DIR}/build/src/app"
"${BOTAN_ROOT}"
)
target_include_directories(${APP_PROJECT_NAME} SYSTEM
@@ -340,6 +376,15 @@ target_include_directories(${TRIAL_PROJECT_NAME} SYSTEM
PUBLIC ${Boost_INCLUDE_DIRS}
)
# configure public key for the coati version
include(cmake/publicKey.cmake)
#configure the versioning file
configure_file(
${CMAKE_SOURCE_DIR}/src/app/version.h.in
${CMAKE_SOURCE_DIR}/build/src/app/version.h
)
# Use the Widgets module from Qt 5.
qt5_use_modules(${TRIAL_PROJECT_NAME} Widgets)
qt5_use_modules(${TRIAL_PROJECT_NAME} Network)
@@ -394,6 +439,46 @@ if (APPLE)
endif ()
# Key/LicenseGenerator --------------------------------------------------------
set(BOOST_ROOT $ENV{BOOST_159_DIR})
set(Boost_USE_STATIC_LIBS ON)
set(Boost_USE_STATIC_RUNTIME ON)
Set(Boost_NO_SYSTEM_PATHS ON)
find_package(Boost 1.59 COMPONENTS system program_options filesystem REQUIRED)
set(GEN_PROJECT_NAME "${PROJECT_NAME}_keygen")
create_source_groups(${GEN_FILES})
if (UNIX)
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin/gen/${CMAKE_BUILD_TYPE})
else ()
set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_SOURCE_DIR}/bin/gen/)
endif ()
add_executable(${GEN_PROJECT_NAME} "${CMAKE_SOURCE_DIR}/src/gen/gen.cpp" ${GEN_FILES})
set_target_properties(
${GEN_PROJECT_NAME}
PROPERTIES
DEBUG_OUTPUT_NAME ${GEN_PROJECT_NAME}_d
RELEASE_OUTPUT_NAME ${GEN_PROJECT_NAME}
)
set_property(
TARGET ${GEN_PROJECT_NAME}
PROPERTY INCLUDE_DIRECTORIES
"${CMAKE_SOURCE_DIR}/src/gen"
)
target_include_directories(${GEN_PROJECT_NAME} SYSTEM
PUBLIC "${BOTAN_ROOT}"
)
target_link_libraries(${GEN_PROJECT_NAME} BOTAN ${CMAKE_THREAD_LIBS_INIT} ${Boost_LIBRARIES} )
# CxxTest ----------------------------------------------------------------------
if (UNIX)
@@ -410,11 +495,11 @@ set(TESTGEN_FILE ${CMAKE_CURRENT_BINARY_DIR}/test_main.cpp)
find_package(PythonInterp REQUIRED)
add_executable (${TEST_PROJECT_NAME} ${TESTGEN_FILE} ${TEST_FILES})
add_executable (${TEST_PROJECT_NAME} ${TESTGEN_FILE} ${TEST_FILES} ${GEN_FILES})
create_source_groups(${TEST_FILES})
target_link_libraries(${TEST_PROJECT_NAME} ${LIB_PARSER_PROJECT_NAME} ${LIB_PROJECT_NAME})
target_link_libraries(${TEST_PROJECT_NAME} ${LIB_PARSER_PROJECT_NAME} ${LIB_PROJECT_NAME} BOTAN)
find_package(CxxTest)
if (CXXTEST_FOUND)
@@ -423,6 +508,8 @@ if (CXXTEST_FOUND)
PROPERTY INCLUDE_DIRECTORIES
"${CMAKE_SOURCE_DIR}/src/lib"
"${CMAKE_SOURCE_DIR}/src/lib_parser"
"${CMAKE_SOURCE_DIR}/src/gen"
"${BOTAN_ROOT}"
"${CXXTEST_INCLUDE_DIR}"
"${CMAKE_SOURCE_DIR}/src/external"
${Boost_INCLUDE_DIRS}
@@ -460,7 +547,6 @@ elseif (UNIX)
endif ()
# Visual Leak Detector ---------------------------------------------------------
if (WIN32)
bin/test/data/GeneratorTestSuite/private-v2.pem
+30
View File
@@ -0,0 +1,30 @@
-----BEGIN ENCRYPTED PRIVATE KEY-----
MIIFNTBfBgkqhkiG9w0BBQ0wUjAxBgkqhkiG9w0BBQwwJAQMd9+hjJsW/c+J80nH
AgMDDUACASAwDAYIKoZIhvcNAgkFADAdBglghkgBZQMEASoEEO7nm7S9FQLRqEHu
Ru0PecYEggTQ+mGSNkbOzZYW2/2R8AJmyX20h4tZNwhM1fQgyWexaf8UxHfmPgI8
Qm38NCO+NC2z+T5R7NFx2CO0MuSFoDu6bQL9fcNRnUqIQIrTTVWkSUyxpGmvee6x
h/AoTPOvGJ9WATojWCZSQH8CgNyBndMgKLurUB9tAty8vKPDuVucwcMFfPVR3wNt
em8s6e6tfq8fA7pg6yEWLyOHJYQE9UWM5hWw+kkBnZz/955QiC1bOmKB7ovlVt+Z
V0h2nFIAnyEwI6xgq/CpcK7K/i6+qW3KFgEFUBMr7Yfk1tLpezDWqR1JzJaQM6Vr
IykzWBnFFW9gjzgHxiaMdvjqkXgrI4oK8PK+YnmgEHJmLodXImx8hWGQwFoExpun
mrUg1swPumJjhAcJcaiEEy61qjcvYB3j3vpfk9DwU4g9LN0Ya9oohuKlU74w1OT8
RlwyWvyDL7P8BP3yPaUhljl7vHlNCKnJCQVbhkQcGM8TXtzglrF4joL0+3PTHNZg
U05uYnJWNTRJmzxfTFIpHzqE+wCXoV0GbvaQ5ZSLIYRnm5cXCRCxnuf6RybIZp5a
R9VzUGHbxNAcMyqYr5prcuZz/wCBxdiusndNqfTHyBMetTehR55igDRD8LcEuNxB
KX1dmMj+kpuYXN7S/BBarFCxTQm3IWCi8sH2JUxBDJfZ6KxNrX3++7n9REe48cil
mjxccZgYAf0rh10/3s8nD2MbezWig/bUMdlCszqMdy6tDz0g2xff22P/OIOXF5ip
uLxegXWcBR9MKErzEJlTWN1evKc8BubmcdxeF/8aZVBDJh1GfQ8wYdYpKBVpCP1k
d9H5n4OgsviZYnyLm2mBoK1oTm1rwTTa0U1/Hro9nb/n5gHQixU9er17U6jbuISU
2SPCGzpYsXMuIf2/pGFO1CVkz2hCroqiryEp5tHI43uKl0R3N0+NmuICNEqxxZsf
hHmdZXh3o5LoTVUEf+WQPHSoiBzir7A1KmIH0huCW53N7NpQ9PKUwY2E0uj69hzz
XLmR63mHKvZc5tqIwhRs+dhiSuE5/UWfn6wpRDebSCD8/u9tC8ORSbXK7TB8fHRu
EahsvbsXMmO6kVe1NU2TiDVsBm3XiBTN+AurK5uPVSEPFBGZPUlNVGC9Z/wIpuOT
jinUN6eOfY/Le+30BsH31bMAF0ND8m/CypJu1ZJ2mzIklDLp5qGoZMPcnrumd/MR
6yptqp9eKBvlf5Ilbm5OnSzc7l7Vjlh5cN1wkcOxTgovFye7At0DEOd5vSh9xkfD
2WbRk0XJEF7HvDT3ncKcpsAMPQxC3vK1s7Giz51zgeqSl5HPrbXowqiiEOUGBI8G
TWOI/vVtCxzNa8XZtqVtJ8ybe+hpbhU0oER+dmzLv1VckxIMVcjtLZa6iRqdG3gm
NWGOWgJ5WMglhjW3AQGkG2fp4FIgiPhS+yZmdk1Z7l39PI9Oj7KSFg1flgo4cxQX
1rm+hBUcuNYJQrE+Np/5G/XDwQyHduycTdKZsD/SAaV1xgt00jetYiX8tNLLzCAf
PEeEbcPr5RbTALZurK+M8ZGnRPWXIH6BAn1ThYRvrccSpROtfM6NrMLKdGDzh+pA
HSYsFvk2F6lifYsjDogamCr+JYvND0SsysFj+wWBNzBxwlP+kzU6H7k=
-----END ENCRYPTED PRIVATE KEY-----
cmake/BotanConfig.cmake
+45
View File
@@ -0,0 +1,45 @@
SET(BOTAN_URL https://github.com/randombit/botan.git/)
SET(BOTAN_VERSION 1.11.23)
SET(BOTAN_MODULES "base,ecdsa,emsa1,passhash9,rng,rsa,egd,emsa_pssr,emsa_pkcs1,x509,aes,dev_random")
SET(BOTAN_DIR $ENV{COATI_DEPEND_DIR}/botan)
find_package(Git)
if(Git_FOUND)
else()
message(ERROR "git not found: git not in path")
endif()
if(EXISTS $ENV{COATI_DEPEND_DIR})
else()
message(ERROR "coati dependency directory does not exist")
endif()
if(EXISTS ${BOTAN_DIR})
else()
execute_process(
COMMAND ${GIT_EXECUTABLE} clone ${BOTAN_URL}
WORKING_DIRECTORY $ENV{COATI_DEPEND_DIR}
)
endif()
execute_process(
COMMAND ${GIT_EXECUTABLE} checkout ${BOTAN_VERSION}
WORKING_DIRECTORY ${BOTAN_DIR}
)
# system specific botan modules
if(UNIX)
elseif(MSVC)
endif()
execute_process(
COMMAND ./configure.py --gen-amalgamation --minimized-build --enable-modules=${BOTAN_MODULES}
WORKING_DIRECTORY ${BOTAN_DIR}
)
#linux
#./configure.py --gen-amalgamation --minimized-build --enable-modules=base,ecdsa,emsa1,passhash9,rng,rsa,egd,dev_random,emsa_pssr,emsa_pkcs1,x509,aes
cmake/CLANGConfig.cmake
-1
View File
@@ -8,7 +8,6 @@ else()
set(CLANG_BUILD_PATH "$ENV{CLANG_DIR}/build")
endif()
execute_process(
COMMAND ${CLANG_BUILD_PATH}/bin/llvm-config --cxxflags
OUTPUT_VARIABLE CLANG_DEFINITIONS
cmake/PublicKey.h.in
+10
View File
@@ -0,0 +1,10 @@
#ifndef PUBLIC_KEY_H
#define PUBLIC_KEY_H
// This File(PublicKey.h) is generated with CMake
#include <string>
static const std::string PublicKey = "@KEY@";
#endif //PUBLIC_KEY_H
cmake/licenses.cmake
+1
View File
@@ -26,6 +26,7 @@ AddLicense("Boost" "http://www.boost.org" "${LICENSEFOLDER}/boost_LICENSE.TXT" f
AddLicense("TinyXMl" "http://www.grinninglizard.com/tinyxml2/" "${LICENSEFOLDER}/tinyxml_LICENSE.TXT" false)
AddLicense("CppSQLite" "http://www.codeproject.com/Articles/6343/CppSQLite-C-Wrapper-for-SQLite" "${LICENSEFOLDER}/CppSQLite_LICENSE.TXT" false)
AddLicense("Eigen" "http://eigen.tuxfamily.org" "${LICENSEFOLDER}/eigen_LICENSE.TXT" false)
AddLicense("Botan" "http://botan.randombit.net/" "${LICENSEFOLDER}/botan_LICENSE.TXT" true)
set(LICENSE_ARRAY "${LICENSE_ARRAY}\n")
cmake/publicKey.cmake
+22
View File
@@ -0,0 +1,22 @@
# searching for public key file of the Coati version in setup/RSA_keys
# if found the file will be put into a const string into the PubicKeh.h file
string(REGEX REPLACE "^([0-9]+)\\..*" "\\1" VERSION_MAJOR "${GIT_VERSION_NUMBER}")
message(STATUS "Get Public Key for Coati version: ${VERSION_MAJOR}")
set(pubKeyFile "${CMAKE_SOURCE_DIR}/setup/RSA_keys/public-${VERSION_MAJOR}.pem")
# message(STATUS "file: ${pubKeyFile}")
if(EXISTS ${pubKeyFile})
file(READ ${pubKeyFile} KEY)
STRING(REGEX REPLACE "\"" "\\\\\"" KEY "${KEY}")
STRING(REGEX REPLACE "\n" "\\\\n\"\n\t\"" KEY "${KEY}")
# message(STATUS "key: ${KEY}")
else()
message(WARNING "public keyfile for this version of Coati")
endif()
configure_file(
${CMAKE_SOURCE_DIR}/cmake/PublicKey.h.in
${CMAKE_SOURCE_DIR}/build/src/app/PublicKey.h
)
script/build.sh
+8
View File
@@ -16,6 +16,10 @@ then
elif [ "$2" = "trial" ]
then
ninja -C build/Release Coati_trial && cd bin/app && Release/Coati_trial
elif [ "$2" = "keygen" ]
then
#echo "release keygen"
ninja -C build/Release Coati_keygen && cd bin/gen && Release/Coati_keygen
else
#echo "release app"
ninja -C build/Release Coati && cd bin/app && Release/Coati
@@ -29,6 +33,10 @@ then
elif [ "$2" = "trial" ]
then
ninja -C build/Debug Coati_trial && cd bin/app && Debug/Coati_trial
elif [ "$2" = "keygen" ]
then
#echo "debug keygen"
ninja -C build/Debug Coati_keygen && cd bin/gen && Debug/Coati_keygen_d
else
#echo "debug app"
ninja -C build/Debug Coati && cd bin/app && Debug/Coati
script/setup.sh
+2
View File
@@ -32,6 +32,8 @@ echo -e $INFO "create build folders"
mkdir -p build
mkdir -p bin/app/Debug
mkdir -p bin/app/Release
mkdir -p bin/gen/Debug
mkdir -p bin/gen/Release
mkdir -p bin/lib/Debug
mkdir -p bin/lib/Release
mkdir -p bin/test/Debug
setup/3rdPartyLicenses/botan_LICENSE.TXT
+47
View File
@@ -0,0 +1,47 @@
Copyright (C) 1999-2013,2014,2015 Jack Lloyd
2001 Peter J Jones
2004-2007 Justin Karneges
2004 Vaclav Ovsik
2005 Matthew Gregan
2005-2006 Matt Johnston
2006 Luca Piccarreta
2007 Yves Jerschow
2007-2008 FlexSecure GmbH
2007-2008 Technische Universitat Darmstadt
2007-2008,2010,2014 Falko Strenzke
2007-2008 Martin Doering
2007 Manuel Hartl
2007 Christoph Ludwig
2007 Patrick Sona
2008 Copyright Projet SECRET, INRIA, Rocquencourt
2008 Bhaskar Biswas and Nicolas Sendrier
2008 Google Inc.
2010 Olivier de Gaalon
2012 Vojtech Kral
2012-2014 Markus Wanner
2013 Joel Low
2014 cryptosource GmbH
2014 Andrew Moon
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions are met:
1. Redistributions of source code must retain the above copyright notice,
this list of conditions, and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions, and the following disclaimer in the
documentation and/or other materials provided with the distribution.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
POSSIBILITY OF SUCH DAMAGE.
setup/RSA_keys/private-0.pem
+30
View File
@@ -0,0 +1,30 @@
-----BEGIN ENCRYPTED PRIVATE KEY-----
MIIFNTBfBgkqhkiG9w0BBQ0wUjAxBgkqhkiG9w0BBQwwJAQMDAB5IuntKywoJmry
AgMDDUACASAwDAYIKoZIhvcNAgkFADAdBglghkgBZQMEASoEEA7JwOuCMu6xUJ+c
0NBKZZsEggTQC82I8AHltLbPCAIkTZoJv68aOV/cVXDcxZ7Mn1hOiob7nO4RuteW
mwTX3JZFd7Jlw5h706xAdRjbSsJXGgTMXECciqrfZ9c21+tYbKV4JpPBQMEhTLpa
IXUTWonQ9wh7vis3bcwBPaRCsfDtYaz872vDpf1X5BVOppoffKCiKFi2y5C+e3HG
CPcg+BTgZg+SRJB9yvSDqdDO5/s9Y6+otePt4Gr+wSOJRwYkdZ67f9uq4BaFcw2z
wIRKA0C1oClu7TAo5onjv1rvw/66migcMHRw1zjIk6oQv44caJvqca1eM9dniZo7
ccbq11PWpeBdKvEkAWuW1PoI7uuLQNdzs3UDO7LJttWwVNAKtO3o8LOL8x9Q7Jns
tvQqUrf0VNB8eBfmsD2I3zVMu2X4rNEDYlAbrL3f1vNkt949ib4eG7+lo3wrCt6J
6UFA791HGVJUvFI0NHdtT32+LdKyTJ+bIlz663LkNU2+mBs6UL7qe6XIBoXCNcg8
+VDKDDVSIyckSVxV7WuGeX9n3igRuvt88T2pCVlY+HEBWDgFoXxc5vx8LdD9EVaQ
OAmuXABLNTqUTCGms9KAa3WJ/QW6++NAt4uf+37LKzM9zyUrDZMTs5M2ZJ/otwgK
ZqIbDcVyfsX79ATs0UeJ7bdrMduXuKhFIVsjlJCGXlyKa7h+JmEpPkqnELGiThvi
hvWogpYt6S6/ofw13MAAgkDqgsfhUGH8tmPu8ufYQn2QQTjB7y1X+s+DUPBUYlic
Ds29YvGMp3wesMFppfwygtGtBFxxs7zvuz3aq9Putu1xC9q3dtHOPdxZYyLvz/aJ
F6BfOqk3NP0a6/S9TphgxE9CqYz2RIqRQg91IbPPrEiC8Sm3fLgX0fO1kfVN7x0E
Pg5+3M56UVflcWLsIcjDVYK4EId4XLHBTjFn8xhkEj56UJQsjb9fFbdQQBBI5pWM
G2nxoGdHD/GCOjZi2f393OMIDFbfoIaoz4L4osIFYaIg4sMrIy2oUOEwnqyLEVf2
tQ58ysC7SDVZza4jai5QXuTCHyMcHYf9BxuzIHEViquI0y19QvlMW17effUctfow
8a0sqCYr0KczggsaOR9BdAgHpSeoCM7SxkQd+j55iX/w7Det8JUvHoCSHRPwM0ar
QiAncEtdKYyU/vz25feTh/crDH1OB4umZIatPVJFr7samb1McocSI5/AxQ5YSkRT
BYyFj6Yi5D0jgmob4+t96Ub0UnWinXk+V6CeTEzgSE6/FYlEb+PqibWAhDfEWG+7
0oG58ajt2vOzbGytDE9RV48HzLoUoWEaNDoa51viuJhpSmRii4CrBj+ENvber2GR
qOM7bMcmicqUvegN9cB+9ZiIzWVePVvI/1NRvypqjXJVE99AD3GyRd5fuC0Vo4VQ
xdaZuk6ysWBldUcFVUCDzr32FWaxKe6cGZbjRtS/u6rDJ8DEJzvm7FcgcLj80qrd
mGrAMUafAfe+FrHSiMits/pUjzwiZqjsQeVIlULUgxQGeLVoERV7InkooBqxVOpI
R63O9zMjEZgkf7yhD8nOrw1fLO08D/eOud2yL5EhXUMWQmjnmBYDog/M1IRu13ba
L4qeddYh0cgHID8DjhjaY+g8VKiikgRO0d59xAkzHrMk4MS1l27xOz8=
-----END ENCRYPTED PRIVATE KEY-----
setup/RSA_keys/public-0.pem
+9
View File
@@ -0,0 +1,9 @@
-----BEGIN PUBLIC KEY-----
MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAsop6ceQNJeWYjourIu2Z
QydUFJwm3kwqXvoAiYP+NeLEyR9OET0eBRwowKDbFzdfDyCXcfJAbsRBoQ1he8Bw
dXcGZqs+QNcnoBz0Vl/uaxOXpVSN5RYj6wo0IFQ/nrR+gMTmzHut8ohtXI4n4a0C
7OVMfwoR2uJyLMLTQiHekEsLvraMnRcS5FbqIq2yUuVYCfGvU3Y2xo1jsvIkko7W
uF/Lw7LFCeruZ1hRYDLGa/HnKepdLhGXoh7lDQuagsUg510PVRGru4G50ATqKVTa
IwcvWNeF0BWjC78uBIhk5G65ZI/HRsS4MQvu3UwrTvtp6d9tTNOT9wixpfD1UtBr
qwIDAQAB
-----END PUBLIC KEY-----
src/gen/CMakeLists.txt
+8
View File
@@ -0,0 +1,8 @@
add_files(
GEN_FILES
Generator.cpp
Generator.h
License.cpp
License.h
)
src/gen/Generator.cpp
+155
View File
@@ -0,0 +1,155 @@
#include "Generator.h"
#include <iostream>
#include <fstream>
#include <sstream>
#include "botan_all.h"
#include "boost/filesystem.hpp"
#include "License.h"
Generator::Generator(std::string version)
: m_version(version)
{
}
Generator::~Generator()
{
}
void Generator::generateKeys()
{
m_privateKey = std::make_shared<Botan::RSA_PrivateKey>(m_rng, 2048);
}
std::string Generator::getPrivateKeyFilename()
{
if(m_privateKeyFile.empty())
{
return "private-" + m_version + KEY_FILEENDING;
}
return m_privateKeyFile;
}
std::string Generator::getPublicKeyFilename()
{
if(m_publicKeyFile.empty())
{
return "public-" + m_version + KEY_FILEENDING;
}
return m_publicKeyFile;
}
void Generator::setVersion(std::string version)
{
if(!version.empty())
{
m_version = version;
}
}
std::string Generator::encodeLicense(std::string user)
{
License license;
//load private key
std::string filename = getPrivateKeyFilename();
std::shared_ptr<Botan::Private_Key> privateKey(
Botan::PKCS8::load_key(filename, m_rng, PRIVATE_KEY_PASSWORD));
Botan::RSA_PrivateKey *rsaKey = dynamic_cast<Botan::RSA_PrivateKey *>(privateKey.get());
if (!rsaKey) {
std::cout << "The key is not a RSA key" << std::endl;
}
license.create(user, m_version, rsaKey);
license.writeToFile("license.txt");
license.print();
return license.getLicenseString();
}
bool Generator::verifyLicense(std::string filename)
{
License license;
license.loadFromFile(filename);
license.setVersion(m_version);
license.loadPublicKeyFromFile(getPublicKeyFilename());
return license.isValid();
}
void Generator::setCustomPrivateKeyFile(std::string file)
{
if(!file.empty())
{
m_privateKeyFile = file;
}
}
void Generator::setCustomPublicKeyFile(std::string file)
{
if(!file.empty())
{
m_publicKeyFile = file;
}
}
std::string Generator::getPublicKeyPEMFileAsString()
{
return Botan::X509::PEM_encode(*m_privateKey);
}
std::string Generator::getPrivateKeyPEMFileAsString()
{
return Botan::PKCS8::PEM_encode(*m_privateKey, m_rng, PRIVATE_KEY_PASSWORD);
}
void Generator::writeKeysToFiles()
{
//public key
std::string filename = getPublicKeyFilename();
std::cout << "publickey filename: " << filename << std::endl;
std::ofstream pub(filename);
pub << getPublicKeyPEMFileAsString();
std::cout << "public key created" << std::endl;
// private key
filename = getPrivateKeyFilename();
std::cout << "publickey filename: " << filename << std::endl;
std::ofstream priv(filename);
priv << getPrivateKeyPEMFileAsString();
std::cout << "private key created" << std::endl;
}
bool Generator::loadPrivateKeyFromFile()
{
boost::filesystem::exists(getPrivateKeyFilename());
Botan::Private_Key* privateKey = Botan::PKCS8::load_key(getPrivateKeyFilename(), m_rng, PRIVATE_KEY_PASSWORD);
Botan::RSA_PrivateKey *rsaKey = dynamic_cast<Botan::RSA_PrivateKey *>(privateKey);
if (!rsaKey) {
std::cout << "The key is not a RSA key" << std::endl;
return false;
}
m_privateKey = std::shared_ptr<Botan::RSA_PrivateKey>(rsaKey);
return true;
}
bool Generator::loadPrivateKeyFromString(std::string key)
{
Botan::DataSource_Memory in(key);
Botan::Private_Key* privateKey= Botan::PKCS8::load_key(in, m_rng, PRIVATE_KEY_PASSWORD);
Botan::RSA_PrivateKey *rsaKey = dynamic_cast<Botan::RSA_PrivateKey *>(privateKey);
if (!rsaKey) {
std::cout << "The key is not a RSA key" << std::endl;
return false;
}
m_privateKey = std::shared_ptr<Botan::RSA_PrivateKey>(rsaKey);
return true;
}
Botan::RSA_PrivateKey *Generator::getPrivateKey() const
{
return m_privateKey.get();
}
src/gen/Generator.h
+48
View File
@@ -0,0 +1,48 @@
#ifndef KEYGEN_H
#define KEYGEN_H
#include <string>
#include "botan_all.h"
class Generator
{
public:
Generator(std::string version = "x");
~Generator();
std::string encodeLicense(std::string message);
bool verifyLicense(std::string filename = "license.txt");
void generateKeys();
void writeKeysToFiles();
void setVersion(std::string version);
void setCustomPrivateKeyFile(std::string file);
void setCustomPublicKeyFile(std::string file);
std::string getPublicKeyPEMFileAsString();
std::string getPrivateKeyPEMFileAsString();
bool loadPrivateKeyFromFile();
bool loadPrivateKeyFromString(std::string key);
void PrintLicense();
Botan::RSA_PrivateKey* getPrivateKey() const;
private:
std::string getPrivateKeyFilename();
std::string getPublicKeyFilename();
//Botan
Botan::AutoSeeded_RNG m_rng;
std::string m_version;
std::string m_privateKeyFile;
std::string m_publicKeyFile;
std::string m_license;
std::shared_ptr<Botan::RSA_PrivateKey> m_privateKey;
const std::string PRIVATE_KEY_PASSWORD = "BA#jk5vbklAiKL9K3k$";
const std::string KEY_FILEENDING = ".pem";
};
#endif // KEYGEN_H
src/gen/License.cpp
+319
View File
@@ -0,0 +1,319 @@
#include "License.h"
#include <iostream>
#include <fstream>
#include <sstream>
#include <istream>
// #include "botan/pubkey.h"
// #include "botan/base64.h"
// #include "botan/passhash9.h"
#include "boost/filesystem.hpp"
// #ifdef BOTAN_HAS_RSA
// #include "botan/rsa.h"
// #endif
License::License()
{
}
License::~License()
{
}
std::string License::getHashLine()
{
return lines[4];
}
std::string License::getMessage()
{
std::string message = "";
for(int i = 1; i < 5; ++i)
{
message += lines[i];
}
return message;
}
std::string License::getSignature()
{
std::string signatue = "";
for(int i = 5; i < 12; ++i)
{
signatue += lines[i];
}
return signatue;
}
std::string License::getVersionLine()
{
return lines[3];
}
void License::create(std::string user, std::string version, Botan::RSA_PrivateKey* privateKey, unsigned int type)
{
m_version = version;
createMessage(user, version, type);
//encode message
Botan::PK_Signer signer(*privateKey, "EMSA4(SHA-256)");
Botan::DataSource_Memory in(getMessage());
Botan::byte buf[4096] = {0};
while (size_t got = in.read(buf, sizeof(buf))) {
signer.update(buf, got);
}
std::string signature = Botan::base64_encode(signer.signature(m_rng));
addSignature(signature);
}
void License::createMessage(std::string user, std::string version, unsigned int type)
{
lines.clear();
lines.push_back(BEGIN_LICENSE);
lines.push_back(user);
std::string typestring;
switch(type)
{
case 0:
default:
typestring = "Single User License";
};
lines.push_back(typestring);
std::string versionstring = "Coati " + getVersion();
lines.push_back(versionstring);
std::string pass9 = Botan::generate_passhash9(versionstring, m_rng);
lines.push_back(pass9);
}
void License::writeToFile(std::string filename)
{
std::ofstream licenseFile(filename);
for(std::string line : lines)
{
licenseFile << line << std::endl;
}
}
bool License::loadFromString(std::string licenseText)
{
lines.clear();
std::istringstream license(licenseText);
return load(license);
}
bool License::load(std::istream& stream)
{
lines.clear();
std::string line;
if(!getline(stream, line, '\n'))
{
return false;
}
if(line.compare(BEGIN_LICENSE) )
{
std::cout << "No License Header" << std::endl;
lines.push_back(BEGIN_LICENSE);
}
else
{
lines.push_back(line);
if(!getline(stream, line))
{
return false;
}
}
lines.push_back(line);
for(int i = 0; i < 2; ++i)
{
if(!getline(stream, line))
{
return false;
}
lines.push_back(line);
}
if(!getline(stream, line))
{
return false;
}
lines.push_back(line);
//get signature
std::string signature = "";
for(int i = 0; i < 7; ++i)
{
if(!getline(stream, line))
{
return false;
}
signature += line;
lines.push_back(line);
}
//check License ending
getline(stream, line);
if(line.compare(END_LICENSE))
{
std::cout << "No License Footer" << std::endl;
lines.push_back(END_LICENSE);
}
else
{
lines.push_back(line);
}
return true;
}
bool License::loadFromFile(std::string filename)
{
lines.clear();
std::ifstream sigfile(filename);
return load(sigfile);
}
void License::print()
{
std::cout << getLicenseString();
}
std::string License::getOwnerLine()
{
return lines[1];
}
std::string License::getLicenseTypeLine()
{
return lines[2];
}
void License::addSignature(std::string signature)
{
if(lines.size() > 5)
{
std::cout << "signature already there" << std::endl;
return;
}
if (!signature.size()) {
std::cout << "signature is empty." << std::endl;
return;
}
std::stringstream ss;
for (size_t i = 0; i < signature.size(); i++) {
if(i % 55 == 0 && i != 0)
{
lines.push_back(ss.str());
ss.str("");
}
ss << signature[i];
}
lines.push_back(ss.str());
lines.push_back(END_LICENSE);
}
bool License::isValid()
{
if(!m_publicKey)
{
std::cout << "No public key loaded" << std::endl;
return false;
}
if(Botan::check_passhash9("Coati "+ getVersion(), getHashLine()))
{
std::cout << "Hash from Coati "+ getVersion() + " confirmed" << std::endl;
}
Botan::secure_vector<Botan::byte> sig = Botan::base64_decode(getSignature());
Botan::PK_Verifier verifier(*m_publicKey.get(), "EMSA4(SHA-256)");
Botan::DataSource_Memory in(getMessage());
Botan::byte buf[4096] = {0};
while(size_t got = in.read(buf, sizeof(buf)))
{
verifier.update(buf, got);
}
const bool ok = verifier.check_signature(sig);
return ok;
}
std::string License::getPublicKeyFilename()
{
if(m_publicKeyFilename.empty())
{
return "public-" + getVersion() + KEY_FILEENDING;
}
return m_publicKeyFilename;
}
std::string License::getVersion() {
if(m_version.empty())
{
return "x";
}
return m_version;
}
bool License::loadPublicKeyFromFile(std::string filename)
{
if (!filename.empty()) {
m_publicKeyFilename = filename;
}
if(boost::filesystem::exists(getPublicKeyFilename()))
{
Botan::RSA_PublicKey *rsaPublicKey = dynamic_cast<Botan::RSA_PublicKey *>(Botan::X509::load_key(getPublicKeyFilename()));
if (!rsaPublicKey) {
std::cout << "The loaded key is not a RSA key" << std::endl;
return false;
}
m_publicKey = std::shared_ptr<Botan::RSA_PublicKey>(rsaPublicKey);
return true;
}
return false;
}
bool License::loadPublicKeyFromString(std::string publicKey)
{
Botan::DataSource_Memory in(publicKey);
Botan::RSA_PublicKey *rsaPublicKey = dynamic_cast<Botan::RSA_PublicKey *>(Botan::X509::load_key(in));
if (!rsaPublicKey) {
std::cout << "The loaded key is not a RSA key" << std::endl;
return false;
}
m_publicKey = std::shared_ptr<Botan::RSA_PublicKey>(rsaPublicKey);
return true;
}
void License::setVersion(const std::string& version)
{
if(!version.empty())
{
m_version = version;
}
}
std::string License::getLicenseString()
{
std::stringstream license;
for(std::string line : lines)
{
license << line << std::endl;
}
return license.str();
}
bool License::checkLocation(const std::string& location, const std::string& hash)
{
return Botan::check_passhash9(location, hash);
}
std::string License::hashLocation(const std::string& location)
{
return Botan::generate_passhash9(location, m_rng);
}
src/gen/License.h
+66
View File
@@ -0,0 +1,66 @@
#ifndef COATI_LICENSE_H
#define COATI_LICENSE_H
#include <string>
#include <vector>
//#include "botan/botan.h"
#include "botan_all.h"
#ifdef BOTAN_HAS_RSA
//#include "botan/rsa.h"
#endif
class License {
public:
enum LicenseType
{
LICENSETYPE_SINGLEUSER = 0,
};
License();
~License();
std::string getHashLine();
std::string getMessage();
std::string getSignature();
std::string getVersionLine();
std::string getOwnerLine();
std::string getLicenseTypeLine();
std::string getPublicKeyFilename();
std::string getVersion();
void create(std::string user, std::string version, Botan::RSA_PrivateKey* privateKey, unsigned int type = 0);
std::string getLicenseString();
void writeToFile(std::string filename);
bool load(std::istream& stream);
bool loadFromString(std::string licenseText);
bool loadFromFile(std::string filename);
bool loadPublicKeyFromFile(std::string);
bool loadPublicKeyFromString(std::string);
void setVersion(const std::string&);
bool isValid();
void print();
std::string hashLocation(const std::string&);
bool checkLocation(const std::string&, const std::string&);
private:
void createMessage(std::string user, std::string version, unsigned int type = 0);
void addSignature(std::string);
std::string m_version;
std::string m_publicKeyFilename;
std::shared_ptr<Botan::RSA_PublicKey> m_publicKey;
std::vector<std::string> lines;
Botan::AutoSeeded_RNG m_rng;
const std::string KEY_FILEENDING = ".pem";
const std::string BEGIN_LICENSE = "-----BEGIN LICENSE-----";
const std::string END_LICENSE = "-----END LICENSE-----";
};
#endif //COATI_LICENSE_H
src/gen/gen.cpp
+93
View File
@@ -0,0 +1,93 @@
#include <iostream>
#include <fstream>
#include <sstream>
#include <memory>
#include "boost/program_options.hpp"
#include "Generator.h"
namespace po = boost::program_options;
bool process_command_line(int argc, char** argv)
{
try
{
std::string user;
std::string version;
std::string privateKey;
std::string publicKey;
std::string license;
po::options_description desc("Coati Generator");
desc.add_options()
("help,h", "Print this help message")
("key,k", "Generate the private and public key")
("generate,g", po::value<std::string>(&user), "Generate a License, USERNAME as value")
("check,c", "Validate a License")
("version,v", po::value<std::string>(&version), "Versionnumber of Coati")
("public-file", po::value<std::string>(&publicKey), "Custom public key file")
("private-file", po::value<std::string>(&privateKey), "Custom private key file")
("license-file", po::value<std::string>(&license), "Custom license")
;
po::variables_map vm;
po::store(po::parse_command_line(argc,argv,desc), vm);
po::notify(vm);
Generator keygen(version);
if(vm.count("help"))
{
std::cout << desc << std::endl;
return 1;
}
if (vm.count("key"))
{
keygen.generateKeys();
keygen.writeKeysToFiles();
}
if (vm.count("public-file"))
{
keygen.setCustomPublicKeyFile(publicKey);
}
if (vm.count("private-file"))
{
keygen.setCustomPrivateKeyFile(privateKey);
}
if(vm.count("generate"))
{
// std::cout << "generate License" << std::endl;
keygen.encodeLicense(user);
}
if(vm.count("check"))
{
if(keygen.verifyLicense())
{
std::cout << "License valid" << std::endl;
}
else
{
std::cout << "License not valid" << std::endl;
}
}
}
catch(std::exception& e)
{
std::cout << "Exception caught: " << e.what() << std::endl;
return false;
}
return true;
}
int main(int argc, char *argv[]) {
process_command_line(argc, argv);
return 0;
}
src/lib/Application.cpp
-1
View File
@@ -22,7 +22,6 @@ std::shared_ptr<Application> Application::create(
const Version& version, ViewFactory* viewFactory, NetworkFactory* networkFactory
){
Version::setApplicationVersion(version);
loadSettings();
std::shared_ptr<Application> ptr(new Application());
src/lib/settings/ApplicationSettings.cpp
+20
View File
@@ -160,3 +160,23 @@ int ApplicationSettings::getControlsMouseForwardButton() const
{
return getValue<int>("controls/mouse_forward_button", 0x10);
}
std::string ApplicationSettings::getLicenseString() const
{
return getValue<std::string>("application/license/license:", "");
}
std::string ApplicationSettings::getLicenseCheck() const
{
return getValue<std::string>("application/license/check", "");
}
void ApplicationSettings::setLicenseString(const std::string& licenseString)
{
setValue<std::string>("application/license/license", licenseString);
}
void ApplicationSettings::setLicenseCheck(const std::string& hash)
{
setValue<std::string>("application/license/check", hash);
}
src/lib/settings/ApplicationSettings.h
+7
View File
@@ -63,6 +63,13 @@ public:
int getControlsMouseBackButton() const;
int getControlsMouseForwardButton() const;
// license
std::string getLicenseString() const;
void setLicenseString(const std::string& licenseString);
std::string getLicenseCheck() const;
void setLicenseCheck(const std::string& hash);
private:
ApplicationSettings();
ApplicationSettings(const ApplicationSettings&);
src/lib_gui/CMakeLists.txt
+2
View File
@@ -107,6 +107,8 @@ add_files(
qt/window/QtAboutLicense.h
qt/window/QtApplicationSettingsScreen.cpp
qt/window/QtApplicationSettingsScreen.h
qt/window/QtLicense.cpp
qt/window/QtLicense.h
qt/window/QtMainWindow.cpp
qt/window/QtMainWindow.h
qt/window/QtProjectSetupScreen.cpp
src/lib_gui/qt/window/QtAbout.cpp
+2 -6
View File
@@ -95,12 +95,7 @@ void QtAbout::setup()
closeButton->setObjectName("closeButton");
closeButton->move(320, 20);
connect(closeButton, SIGNAL(clicked()), this, SLOT(handleCloseButtonPress()));
}
void QtAbout::handleCloseButtonPress()
{
emit finished();
connect(closeButton, SIGNAL(clicked()), this, SLOT(handleUpdateButtonPress()));
}
void QtAbout::handleCancelButtonPress()
@@ -109,4 +104,5 @@ void QtAbout::handleCancelButtonPress()
void QtAbout::handleUpdateButtonPress()
{
emit finished();
}
src/lib_gui/qt/window/QtAbout.h
-2
View File
@@ -18,8 +18,6 @@ public:
virtual void setup() override;
private slots:
void handleCloseButtonPress();
void handleCancelButtonPress();
void handleUpdateButtonPress();
};
src/lib_gui/qt/window/QtLicense.cpp
+83
View File
@@ -0,0 +1,83 @@
#include "qt/window/QtLicense.h"
#include <QComboBox>
#include <QFormLayout>
#include <QLineEdit>
#include <QLabel>
#include <QTextBrowser>
#include <QTextBlock>
#include <QTextEdit>
#include "License.h"
#include "PublicKey.h"
#include "settings/ApplicationSettings.h"
#include "utility/logging/logging.h"
#include "utility/file/FilePath.h"
QtLicense::QtLicense(QWidget *parent)
: QtSettingsWindow(parent)
{
raise();
}
QSize QtLicense::sizeHint() const
{
return QSize(600,600);
}
void QtLicense::setup()
{
setupForm();
updateTitle("Enter License");
updateDoneButton("Ok");
}
void QtLicense::populateForm(QFormLayout* layout)
{
QLabel* licenseName = new QLabel();
licenseName->setText( QString::fromLatin1("Enter License:"));
QFont _font = licenseName->font();
_font.setPixelSize(36);
licenseName->setFont(_font);
layout->addWidget(licenseName);
m_licenseText = new QTextEdit();
m_licenseText->setMinimumHeight(300);
layout->addWidget(m_licenseText);
}
void QtLicense::handleCancelButtonPress()
{
emit canceled();
}
void QtLicense::handleUpdateButtonPress()
{
License license;
bool isLoaded = license.loadFromString(m_licenseText->toPlainText().toStdString());
if(!isLoaded)
{
LOG_WARNING("Failed Loading License");
return;
}
license.loadPublicKeyFromString(PublicKey);
license.print();
if(license.isValid())
{
ApplicationSettings::getInstance()->setLicenseString(license.getLicenseString());
FilePath p("");
ApplicationSettings::getInstance()->setLicenseCheck(license.hashLocation(p.absolute().str()));
ApplicationSettings::getInstance()->save();
LOG_WARNING("License saved");
}
else
{
LOG_WARNING("License is not valid");
}
emit finished();
}
src/lib_gui/qt/window/QtLicense.h
+35
View File
@@ -0,0 +1,35 @@
#ifndef QT_LICENSE_H
#define QT_LICENSE_H
#include <QPushButton>
#include <QWidget>
#include <QtWidgets/qtextedit.h>
#include "qt/window/QtSettingsWindow.h"
class QtLicense
: public QtSettingsWindow
{
Q_OBJECT
public:
QtLicense(QWidget* parent = 0);
QSize sizeHint() const Q_DECL_OVERRIDE;
virtual void setup() override;
protected:
virtual void populateForm(QFormLayout* layout) override;
private slots:
void handleCancelButtonPress();
void handleUpdateButtonPress();
private:
QPushButton* m_cancelButton;
QPushButton* m_updateButton;
QTextEdit* m_licenseText;
};
#endif //QT_LICENSE_H
src/lib_gui/qt/window/QtMainWindow.cpp
+16 -1
View File
@@ -338,6 +338,20 @@ void QtMainWindow::showLicenses()
pushWindow(m_licenseWindow.get());
}
void QtMainWindow::enterLicense()
{
if (!m_enterLicenseWindow)
{
m_enterLicenseWindow = std::make_shared<QtLicense>(this);
m_enterLicenseWindow->setup();
connect(m_enterLicenseWindow.get(), SIGNAL(finished()), this, SLOT(popWindow()));
connect(m_enterLicenseWindow.get(), SIGNAL(canceled()), this, SLOT(popWindow()));
}
pushWindow(m_enterLicenseWindow)
}
void QtMainWindow::showStartScreen()
{
if (!m_startScreen)
@@ -625,10 +639,11 @@ void QtMainWindow::setupHelpMenu()
menu->addAction(tr("&About"), this, SLOT(about()));
menu->addAction(tr("Licences"), this, SLOT(showLicenses()));
if(!isTrial())
{
menu->addAction(tr("Enter License..."), this, SLOT(enterLicense()));
menu->addAction(tr("Preferences..."), this, SLOT(openSettings()));
//Todo: Enter License Window
}
}
src/lib_gui/qt/window/QtMainWindow.h
+3 -1
View File
@@ -13,6 +13,7 @@
#include "qt/window/QtProjectSetupScreen.h"
#include "qt/window/QtAboutLicense.h"
#include "qt/window/QtAbout.h"
#include "qt/window/QtLicense.h"
class QDockWidget;
class View;
@@ -94,6 +95,7 @@ public slots:
void about();
void openSettings();
void showLicenses();
void enterLicense();
void showStartScreen();
void newProject();
@@ -109,7 +111,6 @@ public slots:
void saveProject();
void saveAsProject();
void undo();
void redo();
void zoomIn();
@@ -161,6 +162,7 @@ private:
std::shared_ptr<QtProjectSetupScreen> m_newProjectDialog;
std::shared_ptr<QtAboutLicense> m_licenseWindow;
std::shared_ptr<QtAbout> m_aboutWindow;
std::shared_ptr<QtLicense> m_enterLicenseWindow;
std::vector<QWidget*> m_windowStack;
src/test/CMakeLists.txt
+1
View File
@@ -16,6 +16,7 @@ add_files(
FileManagerTestSuite.h
FilePathTestSuite.h
FileSystemTestSuite.h
GeneratorTestSuite.h
GraphTestSuite.h
LogManagerTestSuite.h
MatrixBaseTestSuite.h
src/test/GeneratorTestSuite.h
+99
View File
@@ -0,0 +1,99 @@
#include "cxxtest/TestSuite.h"
#include "utility/text/TextAccess.h"
#include "License.h"
#include "Generator.h"
#include "botan_all.h"
class GeneratorTestSuite : public CxxTest::TestSuite
{
public:
void test_create_Keys_with_Version_and_check()
{
Generator generator("v0");
generator.generateKeys();
std::string privateKey = generator.getPrivateKeyPEMFileAsString();
std::string publicKey = generator.getPublicKeyPEMFileAsString();
TS_ASSERT_EQUALS(privateKey.size(), 1886);
TS_ASSERT_EQUALS(publicKey.size(), 451);
}
void test_load_private_Key_from_file()
{
Generator generator("v2");
generator.setCustomPrivateKeyFile("./data/GeneratorTestSuite/private-v2.pem");
bool ok = generator.loadPrivateKeyFromFile();
TS_ASSERT(ok);
}
void test_load_private_key_from_string()
{
Generator generator("v0");
bool ok = generator.loadPrivateKeyFromString(m_privateKey);
TS_ASSERT(ok);
}
void test_create_license_and_validate()
{
Generator generator("v2");
generator.generateKeys();
generator.loadPrivateKeyFromString(generator.getPrivateKeyPEMFileAsString());
License license;
license.create("TestUser", "v2", generator.getPrivateKey());
license.loadPublicKeyFromString(generator.getPublicKeyPEMFileAsString());
TS_ASSERT_EQUALS(license.getOwnerLine(), "TestUser");
TS_ASSERT_EQUALS(license.getLicenseTypeLine(), "Single User License");
TS_ASSERT_EQUALS(license.getVersion(), "v2");
TS_ASSERT(license.isValid());
}
private:
std::string m_privateKey = "-----BEGIN ENCRYPTED PRIVATE KEY-----\n"
"MIIFNTBfBgkqhkiG9w0BBQ0wUjAxBgkqhkiG9w0BBQwwJAQMWEDuADurEQ4T8kJO\n"
"AgMDDUACASAwDAYIKoZIhvcNAgkFADAdBglghkgBZQMEASoEEGNDHYI3xozW5JBg\n"
"pOLkhIMEggTQPwClVPQbk+AVqOAXndQqCs0Ad+eihbekCHt5zkRrYl6JbLq9fvfs\n"
"kGgn1j7xtFZflcZimlLaao8pLWybJfa3xGSJnlYrJsGVMlmKJw/ee3fZG7y4/Tgo\n"
"FytAIP51He4YAZ+4fOXyOoAT0+k2DBekZHeMADX7eXVpCLQXuoQpECvf2IPd/de4\n"
"QKS12FRTd7Hkq7DwYs5D7aBizftcsB6FDqwKvvrheglMHfMt3/ChV8u3F8Zuqnh5\n"
"S1NVl2b8geAnYWLEfN/V8SDu00heVHq+z2CIQrvonsTwN1c9ppgMC7/udcr4GEKU\n"
"kqn/2h1sVRdlCxHf9p2nKRdOUXbSgQi16dKnEim3j3QCLVeNeX5Z6Tkb5pJA397i\n"
"mbL0ihdUvbVcPMG9Rh8NONY+MkE4NKye+NHzWjsd+egaeA79qy/Xd4cJRG7GFy68\n"
"pBWhf/xNpkhXJNV+O/KLszZG6f/UNDPJHovTp47aetD2/EqasvuYkPpapfYuqiZh\n"
"3vtNlgL1uNIN/TjoSaut5+ifJonJnQBrMQdWLTN6I8/lZFfxZB4jLkHffLS/zTA+\n"
"tPLxBcfZiec9dJDmuJ+P55D/3E+p6CL++yw15cgBNPFHrvfatikHvQXkRJl03S6Q\n"
"FvrBmbjWKwT+iSZAvJrdkCeFO53CYA3tJ23GtG9pxBHP+VFyJSBu7MukjcCEMSbU\n"
"HduNcsIIo8/p/X/CXYxJGYIfbrqz0n4z0QkZvCtyJoexoqqjTGclWoN3//j8lenL\n"
"SbrPCwLEn1coGr6rx97LHDBjdR1WouWeGkQOyMF/dC70p4QyE3Ru0cbhsjAWeo7P\n"
"HpGgQHJllJBFM9OkymRD32NnTCtr5Vu6epfiAsi16rfg1j1H9f0hnPbfULx+Q2WM\n"
"sCzuUbKUcjRNXOhwDxQXGVrMXEjRzJKmqy2kpMFX/v38iKfqIx+pHMOs+/+ESwwp\n"
"frKZ2mUwa7DdDv6fZwPUPtZk/6HyqiDoJcoiN05IxdPt6SXGPsseQWcwTdiHhDX2\n"
"3YsTJK0O/CAf/ouqWQiZMAifTZtalTArTvTtlTE7TpAT3I0OmwNG/nI1v/orHBbZ\n"
"M7sa9mlBDMzE4rTHIYMOttNKLxkXRChjgO2JfFDLxscSMw8wsrbGTbKh7VGFgg7Q\n"
"Tj6KAGPiU7WbaXiIhO4adgYp3Bpbo15BhhO5bdaYzxBjOhYw1ShLEgBOC7MsOt3N\n"
"8oChFJB1Gls5+RU6Ef27az+RE6uSumToT1HKgYDYX1TN68WWjT7Pa0lUMtZ4Bv1f\n"
"rXMH8igPXg62kzh/hjnEtl8y2+ySAs7RnZ0vUywaKcI0Tu5tqJSLtXSfJKAPmmzE\n"
"QYsg70kpufXccznTYvLSbM99FIbC6s+cSkJ43Ku4dwbEal+9FfqK639i2X9hdsLc\n"
"bYXIb0Fguo2IbWruBeSIc8lukOKCOVjanVZhfOCev8ye/Wz+SS8zbEixWZMzMCzC\n"
"if4dF/CUHnJK32IVlqKr9XGEe8ympqwMqN0eOdJn8IB+BQGCcaF6805D3R/OG4FU\n"
"hedhIvg1cODtoi8ri41Pz7o1x9Ia0zZr7oxhQuSgHiTfRfFN0xhCFZ+sIfGNpgUs\n"
"54IZGQlI0nQHOK8h2NI0wp3uo+fDEjjVIjQxINOSBa5awSReBpBUW2I=\n"
"-----END ENCRYPTED PRIVATE KEY-----";
std::string m_publicKey = "-----BEGIN PUBLIC KEY-----\n"
"MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEAugYah7LOU0ssdSnyDA8h\n"
"nOeW2lwE+NmZGxIKnqZKYNePY7Tg0c1pI0lfgJ2WYtxbubDFNDYk6bJF6mFg3jjN\n"
"gCdocj6pyyibIISbRst+gl/1FwI8vbIkfkJBoZtftO5mKVBbO5mmrxm32fDQs1vo\n"
"zgVxcWx3LXW87pzdQQYRACdkLSxPd+ADs+KNv6UxlOEvucDaenX3ckl3HdcWruL8\n"
"xdYoM7z/C+PRShSGvY3wB7Y6A5IcdBmzsTR6xayCmTzzW83dmFzjCX5DSOJLHxq7\n"
"+Fs26xZU83P1boX7eg4TjMViTxJwsCCW/2wfsZAoF0cSYCxhrkSdMHroH7Edz1PM\n"
"fwIDAQAB\n"
"-----END PUBLIC KEY-----\n";
};