jrusbatch

C# LSP in Claude Code

The roslyn-language-server is a .NET tool that provides rich language features for C# through the Language Server Protocol. It powers editor integrations including the C# extension for Visual Studio Code and C# Dev Kit. It offers several operations that Claude can use to navigate C# code rather than using grep and friends.

The Roslyn LSP supports many operations defined by the language service protocol, but from what I read only these commands are supported by Claude as of v2.1.62.

• goToDefinition: find where a symbol is defined.
• findReferences: find all references to a symbol.
• hover: get documentation and type info for a symbol.
• documentSymbol: list all symbols in a document.
• workspaceSymbol: search for symbols by name across the entire workspaced.

eybisi

Java.perform(function(){
    let ThreadDef = Java.use('java.lang.Thread');
    let ThreadObj = ThreadDef.$new();
    function stackTrace() {
                console.log('------------START STACK---------------')
                let stack = ThreadObj.currentThread().getStackTrace();
                for (let i = 0; i < stack.length; i++) {
                                console.log(i + ' => ' + stack[i].toString());
                            }
                console.log('------------END STACK---------------');

yehgdotnet

X-Azure-ClientIP: 127.0.0.1
X-Azure-SocketIP: 127.0.0.1
X-Originating-IP: 127.0.0.1 
X-Forwarded-For: 127.0.0.1 
X-Remote-IP: 127.0.0.1 
X-Remote-Addr: 127.0.0.1
X-Real-Ip: 127.0.0.1 
X-Target-IP: 127.0.0.1 
X-Forwarded-Host: localhost
True-Client-IP: 127.0.0.1 

Areizen

#!/usr/bin/python3
import frida
import subprocess
import sys

if len(sys.argv) !=2:
    print(f"[-] Usage : python3 {sys.argv[0]} <package_to_uninstall>")
    sys.exit(-1)

def message(message, data):

AndrewDavid

Using multiple GitHub deploy keys on a single server with a single user

Within GitHub it is possible to set up two types of SSH key - account level SSH keys and and repository level SSH keys. These repository level SSH keys are known in GitHub as deploy keys.

Deploy keys are useful for deploying code because they do not rely on an individual user account, which is susceptible to change, to “store” the server keys.

There is, however, an ‘issue’ with using deploy keys; each key across all repositories on GitHub must be unique. No one key can be used more than once. This becomes a problem when deploying to repositories to the same server with the same user. If you create two keys, the SSH client will not know which key to use when connecting to GitHub.

One solution is to use an SSH config file to define which key to use in which situation. This isn’t as easy as it seems.. you might try something like this:

daniellimws

Frida Tips

The documentation is so limited. A compilation of things I found on StackOverflow and don't want to have to search it up again.

Bypass root check

setTimeout(function() { // avoid java.lang.ClassNotFoundException

  Java.perform(function() {

    // Root detection bypass example

niklasb

require 'yaml'
require 'base64'
require 'erb'

class ActiveSupport
  class Deprecation
    def initialize()
      @silenced = true
    end
    class DeprecatedInstanceVariableProxy

FrankSpierings

function getGenericInterceptor(className, func, parameters) {
	args = []
	for (i = 0; i < parameters.length; i++) { 
        	args.push('arg_' + i) 
    }
    var script = "result = this.__FUNCNAME__(__SEPARATED_ARG_NAMES__);\nlogmessage = '__CLASSNAME__.__FUNCNAME__(' + __SEPARATED_ARG_NAMES__ + ') => ' + result;\nconsole.log(logmessage);\nreturn result;"
    
    script = script.replace(/__FUNCNAME__/g, func);
    script = script.replace(/__SEPARATED_ARG_NAMES__/g, args.join(', '));
    script = script.replace(/__CLASSNAME__/g, className);

mommi84

Awesome Knowledge Graph Embedding Approaches

This list contains repositories of libraries and approaches for knowledge graph embeddings, which are vector representations of entities and relations in a multi-relational directed labelled graph. Licensed under CC0.

Libraries

• 🆕 AmpliGraph (4 algorithms) @ https://github.com/Accenture/AmpliGraph
• Embedding framework (5 algorithms) @ https://github.com/BookmanHan/Embedding

LiveOverflow

import sys
import r2pipe

r2 = r2pipe.open("./zwiebel2")
r2.cmd("e dbg.profile=zwiebel.rr2")
r2.cmd("doo") # reopen for debugging
r2.cmd("db 0x400875") # set breakpoint at `call r14`
r2.cmd("dc") # continue until breakpoint is hit

def step():