There’s a dragon afoot, we need a hero. Give us the dragon’s secret and we’ll give you a flag.HINT: static is only 1 of 2 methods to RE. IDA torrent unnecessary
+-----------------------+| Welcome Hero |+-----------------------+[!] Quest: there is a dragon prowling the domain. brute strength and magic is our only hope. Test your skill.Enter the dragon's secret: flag[-] You have failed. The dragon's power, speed and intelligence was greater.
a = [0,100,214,266,369,417,527,622,733,847,942,1054,1106,1222,1336,1441,1540,1589,1686,1796,1891,1996,2112,2165,2260,2336,2412,2498,2575]for i in range(1,len(a)): print(chr(a[i]-a[i-1]),end="")
import osimport reflag = ''chars = []for i in range(47,58): chars.append(chr(i))for i in range(65,91): chars.append(chr(i))for i in range(97,123): chars.append(chr(i))chars.append('@')chars.append('_')move = Truecur_max = 0while(move): move = False for c in chars: s = flag + c s = s.ljust(28,'A') #补全 28 位 cmd = os.popen("echo '%s' | ../../../../pin -t inscount0.so -- /root/pwn/wyvern;cat ./inscount.out" % s).read() cnt = int(re.search("Count ([0-9]*)", cmd).group(1)) #统计指令数量 if c=='/': cur_max = max(cnt,cur_max) if cnt > cur_max: print(s) flag = flag + c cur_max = cnt move = True index = 0 breakprint("flag:")print(flag)
+-----------------------+| Welcome Hero |+-----------------------+[!] Quest: there is a dragon prowling the domain. brute strength and magic is our only hope. Test your skill.Enter the dragon's secret: dr4g0n_or_p4tric1an_it5_LLVMsuccess[+] A great success! Here is a flag{dr4g0n_or_p4tric1an_it5_LLVM}
>>> import thisThe Zen of Python, by Tim PetersBeautiful is better than ugly.Explicit is better than implicit.Simple is better than complex.Complex is better than complicated.Flat is better than nested.Sparse is better than dense.Readability counts.Special cases aren't special enough to break the rules.Although practicality beats purity.Errors should never pass silently.Unless explicitly silenced.In the face of ambiguity, refuse the temptation to guess.There should be one-- and preferably only one --obvious way to do it.Although that way may not be obvious at first unless you're Dutch.Now is better than never.Although never is often better than *right* now.If the implementation is hard to explain, it's a bad idea.If the implementation is easy to explain, it may be a good idea.Namespaces are one honking great idea -- let's do more of those!
class Solution: def longestIncreasingPath(self, matrix: List[List[int]]) -> int: @lru_cache(None) def dfs(i,j): res = 1 if i-1>=0 and matrix[i-1][j]>matrix[i][j]: res=max(res,dfs(i-1,j)+1) if i+1<len(matrix) and matrix[i+1][j]>matrix[i][j]: res=max(res,dfs(i+1,j)+1) if j-1>=0 and matrix[i][j-1]>matrix[i][j]: res=max(res,dfs(i,j-1)+1) if j+1<len(matrix[0]) and matrix[i][j+1]>matrix[i][j]: res=max(res,dfs(i,j+1)+1) return res res = 0 for i in range(len(matrix)): for j in range(len(matrix[0])): res = max(res,dfs(i,j)) return res
class Solution: def intersect(self, nums1: List[int], nums2: List[int]) -> List[int]: res = [] for num in nums1: try: nums2.remove(num) res.append(num) except: continue return res
迭代器 iter
迭代器的好处是 for in 遍历时，迭代器自身也会移动，适合处理只需要使用一次的数据。
392. 判断子序列
给定字符串 s 和 t ，判断 s 是否为 t 的子序列。
你可以认为 s 和 t 中仅包含英文小写字母。字符串 t 可能会很长（长度 ~= 500,000），而 s 是个短字符串（长度 <=100）。
#include <stdio.h>#include <stdlib.h>#include <pthread.h> const int MAX_THREADS = 64;/* Global variable: accessible to all threads */int thread_count; void Usage(char* prog_name);void *Hello(void* rank); /* Thread function *//*--------------------------------------------------------------------*/int main(int argc, char* argv[]) { long thread; /* Use long in case of a 64-bit system */ pthread_t* thread_handles; /* Get number of threads from command line */ if (argc != 2) Usage(argv[0]); thread_count = strtol(argv[1], NULL, 10); if (thread_count <= 0 || thread_count > MAX_THREADS) Usage(argv[0]); thread_handles = malloc (thread_count*sizeof(pthread_t)); for (thread = 0; thread < thread_count; thread++) pthread_create(&thread_handles[thread], NULL, Hello, (void*) thread); printf("Hello from the main thread\n"); for (thread = 0; thread < thread_count; thread++) pthread_join(thread_handles[thread], NULL); free(thread_handles); return 0;} /* main *//*-------------------------------------------------------------------*/void *Hello(void* rank) { long my_rank = (long) rank; /* Use long in case of 64-bit system */ printf("Hello from thread %ld of %d\n", my_rank, thread_count); return NULL;} /* Hello *//*-------------------------------------------------------------------*/void Usage(char* prog_name) { fprintf(stderr, "usage: %s <number of threads>\n", prog_name); fprintf(stderr, "0 < number of threads <= %d\n", MAX_THREADS); exit(0);} /* Usage */
#include<stdlib.h>#include<stdio.h>#include<math.h>#include<pthread.h>int thread_count;long long int num_in_circle,n;pthread_mutex_t mutex;void* compute_pi(void* rank);int main(int argc,char* argv[]){ long thread; pthread_t* thread_handles; thread_count=strtol(argv[1],NULL,10); printf("please input the number of point\n"); scanf("%lld",&n); thread_handles=(pthread_t*)malloc(thread_count*sizeof(pthread_t)); pthread_mutex_init(&mutex,NULL); for(thread=0;thread<thread_count;thread++) pthread_create(&thread_handles[thread],NULL,compute_pi,(void*)thread); for(thread=0;thread<thread_count;thread++) pthread_join(thread_handles[thread],NULL); pthread_mutex_destroy(&mutex); double pi=4*(double)num_in_circle/(double)n; printf("The esitimate value of pi is %lf\n",pi);}void* compute_pi(void* rank){ long long int local_n; local_n=n/thread_count; double x,y,distance_squared; for(long long int i=0;i<local_n;i++){ x=(double)rand()/(double)RAND_MAX; y=(double)rand()/(double)RAND_MAX; distance_squared=x*x+y*y; if(distance_squared<=1){ pthread_mutex_lock(&mutex); num_in_circle++; pthread_mutex_unlock(&mutex); } } return NULL;}
//int flag = 1;while(flag!=1);flag = 0;num_in_circle++;flag = 1;
因为对 flag 的赋值操作自身就可能造成竞争条件，导致非预期结果。
π的莱布尼茨公式
由 ，即 计算 pi 的近似值，这个值的精确度没有随机因素，只与计算深度有关。我们将数据分段计算，最后再用互斥量机制相加。
#include <stdio.h>#include <stdlib.h>#include <math.h>#include <pthread.h>const int MAX_THREADS = 1024;long thread_count;long long n;double sum;void* Thread_sum(void* rank);/* Only executed by main thread */void Get_args(int argc, char* argv[]);void Usage(char* prog_name);double Serial_pi(long long n);int main(int argc, char* argv[]) { long thread; /* Use long in case of a 64-bit system */ pthread_t* thread_handles; /* Get number of threads from command line */ Get_args(argc, argv); thread_handles = (pthread_t*) malloc (thread_count*sizeof(pthread_t)); sum = 0.0; for (thread = 0; thread < thread_count; thread++) pthread_create(&thread_handles[thread], NULL, Thread_sum, (void*)thread); for (thread = 0; thread < thread_count; thread++) pthread_join(thread_handles[thread], NULL); sum = 4.0*sum; printf("With n = %lld terms,\n", n); printf(" Our estimate of pi = %.15f\n", sum); sum = Serial_pi(n); printf(" Single thread est = %.15f\n", sum); printf(" pi = %.15f\n", 4.0*atan(1.0)); free(thread_handles); return 0;} /* main */void* Thread_sum(void* rank) { long my_rank = (long) rank; double factor; long long i; long long my_n = n/thread_count; long long my_first_i = my_n*my_rank; long long my_last_i = my_first_i + my_n; double my_sum = 0.0; if (my_first_i % 2 == 0) factor = 1.0; else factor = -1.0; for (i = my_first_i; i < my_last_i; i++, factor = -factor) { my_sum += factor/(2*i+1); } pthread_mutex_lock(&mutex); sum += my_sum; pthread_mutex_unlock(&mutex); return NULL;} /* Thread_sum */double Serial_pi(long long n) { double sum = 0.0; long long i; double factor = 1.0; for (i = 0; i < n; i++, factor = -factor) { sum += factor/(2*i+1); } return 4.0*sum;} /* Serial_pi */void Get_args(int argc, char* argv[]) { if (argc != 3) Usage(argv[0]); thread_count = strtol(argv[1], NULL, 10); if (thread_count <= 0 || thread_count > MAX_THREADS) Usage(argv[0]); n = strtoll(argv[2], NULL, 10); if (n <= 0) Usage(argv[0]);} /* Get_args */void Usage(char* prog_name) { fprintf(stderr, "usage: %s <number of threads> <n>\n", prog_name); fprintf(stderr, " n is the number of terms and should be >= 1\n"); fprintf(stderr, " n should be evenly divisible by the number of threads\n"); exit(0);} /* Usage */
例如使用 Excutor 构建 web 服务器，用于处理线程的请求：生产者将任务提交给线程池，线程池创建线程处理任务，如果需要运行的任务数大于线程池的基本线程数，那么就把任务扔到阻塞队列（通过线程池+阻塞队列的方式比只使用一个阻塞队列的效率高很多，因为消费者能够处理就直接处理掉了，不用每个消费者都要先从阻塞队列中取出任务再执行）
The following table shows the C library functions that are thread-safe.
Functions
Description
calloc(), free(), malloc(), realloc()
The heap functions are thread-safe if the _mutex_* functions are implemented.All threads share a single heap and use mutexes to avoid data corruption when there is concurrent access. Each heap implementation is responsible for doing its own locking. If you supply your own allocator, it must also do its own locking. This enables it to do fine-grained locking if required, rather than protecting the entire heap with a single mutex (coarse-grained locking).
alloca()
alloca() is thread-safe because it allocates memory on the stack.
abort(), raise(), signal(), fenv.h
The ARM® signal handling functions and floating-point exception traps are thread-safe.The settings for signal handlers and floating-point traps are global across the entire process and are protected by locks. Data corruption does not occur if multiple threads call signal() or an fenv.h function at the same time. However, be aware that the effects of the call act on all threads and not only on the calling thread.
The stdio library is thread-safe if the _mutex_* functions are implemented.Each individual stream is protected by a lock, so two threads can each open their own stdio stream and use it, without interfering with one another.If two threads both want to read or write the same stream, locking at the fgetc() and fputc() level prevents data corruption, but it is possible that the individual characters output by each thread might be interleaved in a confusing way.Notetmpnam() also contains a static buffer but this is only used if the argument is NULL. To ensure that your use of tmpnam() is thread-safe, supply your own buffer space.
When using these functions:The standard C printf() and scanf() functions use stdio so they are thread-safe.The standard C printf() function is susceptible to changes in the locale settings if called in a multithreaded program.
clock()
clock() contains static data that is written once at program startup and then only ever read. Therefore, clock() is thread-safe provided no extra threads are already running at the time that the library is initialized.
errno
errno is thread-safe.Each thread has its own errno stored in a __user_perthread_libspace block. This means that each thread can call errno-setting functions independently and then check errno afterwards without interference from other threads.
atexit()
The list of exit functions maintained by atexit() is process-global and protected by a lock.In the worst case, if more than one thread calls atexit(), the order that exit functions are called cannot be guaranteed.
Although setjmp() and longjmp() keep data in __user_libspace, they call the __alloca_* functions, that are thread-safe.
remove(), rename(), time()
These functions use interrupts that communicate with the ARM debugging environments. Typically, you have to reimplement these for a real-world application.
When using these functions, the string-based functions read the locale settings. Typically, they are thread-safe. However, if you change locale in mid-session, you must ensure that these functions are not affected.The string-based functions, such as sprintf() and sscanf(), do not depend on the stdio library.
stdin, stdout, stderr
These functions are thread-safe.
C library functions that are not thread-safe
The following table shows the C library functions that are not thread-safe.
Functions
Description
asctime(), localtime(), strtok()
These functions are all thread-unsafe. Each contains a static buffer that might be overwritten by another thread between a call to the function and the subsequent use of its return value.ARM® supplies reentrant versions, _asctime_r(), _localtime_r(), and _strtok_r(). ARM recommends that you use these functions instead to ensure safety.NoteThese reentrant versions take additional parameters. _asctime_r() takes an additional parameter that is a pointer to a buffer that the output string is written into. _localtime_r() takes an additional parameter that is a pointer to a struct tm, that the result is written into. _strtok_r() takes an additional parameter that is a pointer to a char pointer to the next token.
exit()
Do not call exit() in a multithreaded program even if you have provided an implementation of the underlying _sys_exit() that actually terminates all threads.In this case, exit() cleans up before calling _sys_exit() so disrupts other threads.
gamma(), lgamma(), lgammaf(), lgammal()
These extended mathlib functions use a global variable, _signgam, so are not thread-safe.
The C90 multibyte conversion functions (defined in stdlib.h) are not thread-safe, for example mblen() and mbtowc(), because they contain internal static state that is shared between all threads without locking.However, the extended restartable versions (defined in wchar.h) are thread-safe, for example mbrtowc() and wcrtomb(), provided you pass in a pointer to your own mbstate_t object. You must exclusively use these functions with non-NULL mbstate_t * parameters if you want to ensure thread-safety when handling multibyte strings.
rand(), srand()
These functions keep internal state that is both global and unprotected. This means that calls to rand() are never thread-safe.ARM recommends that you do one of the following:Use the reentrant versions _rand_r() and _srand_r() supplied by ARM. These use user-provided buffers instead of static data within the C library.Use your own locking to ensure that only one thread ever calls rand() at a time, for example, by defining rand() if you want to avoid changing your code.Arrange that only one thread ever needs to generate random numbers.Supply your own random number generator that can have multiple independent instances.Note_rand_r() and _srand_r() both take an additional parameter that is a pointer to a buffer storing the state of the random number generator.
setlocale(), localeconv()
setlocale() is used for setting and reading locale settings. The locale settings are global across all threads, and are not protected by a lock. If two threads call setlocale() to simultaneously modify the locale settings, or if one thread reads the settings while another thread is modifying them, data corruption might occur. Also, many other functions, for example strtod() and sprintf(), read the current locale settings. Therefore, if one thread calls setlocale() concurrently with another thread calling such a function, there might be unexpected results.Multiple threads reading the settings simultaneously is thread-safe in simple cases and if no other thread is simultaneously modifying those settings, but where internally an intermediate buffer is required for more complicated returned results, unexpected results can occur unless you use a reentrant version of setlocale().ARM recommends that you either:Choose the locale you want and call setlocale() once to initialize it. Do this before creating any additional threads in your program so that any number of threads can read the locale settings concurrently without interfering with one another.Use the reentrant version _setlocale_r() supplied by ARM. This returns a string that is either a pointer to a constant string, or a pointer to a string stored in a user-supplied buffer that can be used for thread-local storage, rather than using memory within the C library. The buffer must be at least _SETLOCALE_R_BUFSIZE bytes long, including space for a trailing NUL.Be aware that _setlocale_r() is not fully thread-safe when accessed concurrently to change locale settings. This access is not lock-protected.Also, be aware that localeconv() is not thread-safe. Call the ARM function _get_lconv() with a pointer to a user-supplied buffer instead.
参考资料
并行计算导论。Introduction to Parallel Computing. Ananth Grama.
]]><p>本文是在 Pthreads 学习过程中产生的入门级教程。</p>使用 Node.js 建立 info 的简单代理服务器https://blog.pka.moe/info-proxy/2020-02-15T12:06:00.000Z2020-02-15T12:06:00.000Z
主要需求是在校外结合 RSSHub 订阅 info ，避免错过重要通知。
首先利用清华大学提供的 WEBVPN 搭建实现自动登录功能的代理服务器。（新版 WEBVPN 只是校内代理，相较于以前自动登录 info 的 SSLVPN 风险较小）
#!/usr/bin/pythonkey = 'THUCTF{xo3_1s_1terestr1nq}' flag = ''with open('cipher.txt') as f: con = f.read() for i in range(len(con)): flag += chr(ord(con[i]) ^ ord(key[i%26]))f = open('flag.txt', 'w')print(flag)f.write(flag)f.close()
Welcome to Hexo[1]! This is your very first post. Check documentation for more info. If you get any problems when using Hexo, you can find the answer in troubleshooting or you can ask me on GitHub.
THUCTF{Can_You_Hear_UlTRASOUND}
