Sign upLogin

cea-sec/miasm

View on GitHub
Star

Showing 1,646 of 3,019 total issues

Identical blocks of code found in 7 locations. Consider refactoring.
Open

                    addr, size = (int(x, 16) for x in buf.read().split(b",", 1))
Severity: Major
Found in miasm/analysis/gdbserver.py and 6 other locations - About 30 mins to fix
miasm/analysis/gdbserver.py on lines 129..129
miasm/analysis/gdbserver.py on lines 158..158
miasm/analysis/gdbserver.py on lines 168..168
miasm/analysis/gdbserver.py on lines 183..183
miasm/analysis/gdbserver.py on lines 202..202
miasm/analysis/gdbserver.py on lines 227..227

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 16 locations. Consider refactoring.
Open

def msvcrt_free(jitter):
    ret_ad, _ = jitter.func_args_cdecl(["ptr"])
    jitter.func_ret_cdecl(ret_ad, 0)
Severity: Major
Found in miasm/os_dep/win_api_x86_32.py and 15 other locations - About 30 mins to fix
miasm/os_dep/linux_stdlib.py on lines 197..199
miasm/os_dep/win_api_x86_32.py on lines 293..295
miasm/os_dep/win_api_x86_32.py on lines 310..312
miasm/os_dep/win_api_x86_32.py on lines 316..318
miasm/os_dep/win_api_x86_32.py on lines 412..414
miasm/os_dep/win_api_x86_32.py on lines 422..424
miasm/os_dep/win_api_x86_32.py on lines 473..475
miasm/os_dep/win_api_x86_32.py on lines 478..480
miasm/os_dep/win_api_x86_32.py on lines 590..592
miasm/os_dep/win_api_x86_32.py on lines 1348..1350
miasm/os_dep/win_api_x86_32.py on lines 1994..1998
miasm/os_dep/win_api_x86_32.py on lines 2429..2431
miasm/os_dep/win_api_x86_32.py on lines 2556..2558
miasm/os_dep/win_api_x86_32.py on lines 2806..2808
miasm/os_dep/win_api_x86_32.py on lines 3006..3008

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 16 locations. Consider refactoring.
Open

def kernel32_LocalFree(jitter):
    ret_ad, _ = jitter.func_args_stdcall(["lpvoid"])
    jitter.func_ret_stdcall(ret_ad, 0)
Severity: Major
Found in miasm/os_dep/win_api_x86_32.py and 15 other locations - About 30 mins to fix
miasm/os_dep/linux_stdlib.py on lines 197..199
miasm/os_dep/win_api_x86_32.py on lines 310..312
miasm/os_dep/win_api_x86_32.py on lines 316..318
miasm/os_dep/win_api_x86_32.py on lines 412..414
miasm/os_dep/win_api_x86_32.py on lines 422..424
miasm/os_dep/win_api_x86_32.py on lines 473..475
miasm/os_dep/win_api_x86_32.py on lines 478..480
miasm/os_dep/win_api_x86_32.py on lines 590..592
miasm/os_dep/win_api_x86_32.py on lines 1348..1350
miasm/os_dep/win_api_x86_32.py on lines 1994..1998
miasm/os_dep/win_api_x86_32.py on lines 2429..2431
miasm/os_dep/win_api_x86_32.py on lines 2556..2558
miasm/os_dep/win_api_x86_32.py on lines 2806..2808
miasm/os_dep/win_api_x86_32.py on lines 2936..2938
miasm/os_dep/win_api_x86_32.py on lines 3006..3008

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 16 locations. Consider refactoring.
Open

def kernel32_GlobalFree(jitter):
    ret_ad, _ = jitter.func_args_stdcall(["addr"])
    jitter.func_ret_stdcall(ret_ad, 0)
Severity: Major
Found in miasm/os_dep/win_api_x86_32.py and 15 other locations - About 30 mins to fix
miasm/os_dep/linux_stdlib.py on lines 197..199
miasm/os_dep/win_api_x86_32.py on lines 293..295
miasm/os_dep/win_api_x86_32.py on lines 310..312
miasm/os_dep/win_api_x86_32.py on lines 412..414
miasm/os_dep/win_api_x86_32.py on lines 422..424
miasm/os_dep/win_api_x86_32.py on lines 473..475
miasm/os_dep/win_api_x86_32.py on lines 478..480
miasm/os_dep/win_api_x86_32.py on lines 590..592
miasm/os_dep/win_api_x86_32.py on lines 1348..1350
miasm/os_dep/win_api_x86_32.py on lines 1994..1998
miasm/os_dep/win_api_x86_32.py on lines 2429..2431
miasm/os_dep/win_api_x86_32.py on lines 2556..2558
miasm/os_dep/win_api_x86_32.py on lines 2806..2808
miasm/os_dep/win_api_x86_32.py on lines 2936..2938
miasm/os_dep/win_api_x86_32.py on lines 3006..3008

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Identical blocks of code found in 7 locations. Consider refactoring.
Open

                addr, size = (int(x, 16) for x in buf.read().split(b",", 1))
Severity: Major
Found in miasm/analysis/gdbserver.py and 6 other locations - About 30 mins to fix
miasm/analysis/gdbserver.py on lines 158..158
miasm/analysis/gdbserver.py on lines 168..168
miasm/analysis/gdbserver.py on lines 183..183
miasm/analysis/gdbserver.py on lines 202..202
miasm/analysis/gdbserver.py on lines 214..214
miasm/analysis/gdbserver.py on lines 227..227

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 16 locations. Consider refactoring.
Open

def msvcrt_atexit(jitter):
    ret_ad, _ = jitter.func_args_cdecl(["func"])
    jitter.func_ret_cdecl(ret_ad, 0)
Severity: Major
Found in miasm/os_dep/win_api_x86_32.py and 15 other locations - About 30 mins to fix
miasm/os_dep/linux_stdlib.py on lines 197..199
miasm/os_dep/win_api_x86_32.py on lines 293..295
miasm/os_dep/win_api_x86_32.py on lines 310..312
miasm/os_dep/win_api_x86_32.py on lines 316..318
miasm/os_dep/win_api_x86_32.py on lines 412..414
miasm/os_dep/win_api_x86_32.py on lines 422..424
miasm/os_dep/win_api_x86_32.py on lines 473..475
miasm/os_dep/win_api_x86_32.py on lines 478..480
miasm/os_dep/win_api_x86_32.py on lines 590..592
miasm/os_dep/win_api_x86_32.py on lines 1348..1350
miasm/os_dep/win_api_x86_32.py on lines 1994..1998
miasm/os_dep/win_api_x86_32.py on lines 2429..2431
miasm/os_dep/win_api_x86_32.py on lines 2556..2558
miasm/os_dep/win_api_x86_32.py on lines 2806..2808
miasm/os_dep/win_api_x86_32.py on lines 2936..2938

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Identical blocks of code found in 7 locations. Consider refactoring.
Open

                    addr, size = (int(x, 16) for x in buf.read().split(b",", 1))
Severity: Major
Found in miasm/analysis/gdbserver.py and 6 other locations - About 30 mins to fix
miasm/analysis/gdbserver.py on lines 129..129
miasm/analysis/gdbserver.py on lines 168..168
miasm/analysis/gdbserver.py on lines 183..183
miasm/analysis/gdbserver.py on lines 202..202
miasm/analysis/gdbserver.py on lines 214..214
miasm/analysis/gdbserver.py on lines 227..227

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 6 locations. Consider refactoring.
Open

def user32_GetForegroundWindow(jitter):
    ret_ad, _ = jitter.func_args_stdcall(0)
    jitter.func_ret_stdcall(ret_ad, winobjs.getforegroundwindow)
Severity: Major
Found in miasm/os_dep/win_api_x86_32.py and 5 other locations - About 30 mins to fix
miasm/os_dep/win_api_x86_32.py on lines 321..323
miasm/os_dep/win_api_x86_32.py on lines 331..333
miasm/os_dep/win_api_x86_32.py on lines 336..338
miasm/os_dep/win_api_x86_32.py on lines 374..376
miasm/os_dep/win_api_x86_32.py on lines 1002..1004

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 6 locations. Consider refactoring.
Open

def kernel32_IsDebuggerPresent(jitter):
    ret_ad, _ = jitter.func_args_stdcall(0)
    jitter.func_ret_stdcall(ret_ad, winobjs.dbg_present)
Severity: Major
Found in miasm/os_dep/win_api_x86_32.py and 5 other locations - About 30 mins to fix
miasm/os_dep/win_api_x86_32.py on lines 331..333
miasm/os_dep/win_api_x86_32.py on lines 336..338
miasm/os_dep/win_api_x86_32.py on lines 374..376
miasm/os_dep/win_api_x86_32.py on lines 457..459
miasm/os_dep/win_api_x86_32.py on lines 1002..1004

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 6 locations. Consider refactoring.
Open

def kernel32_GetLastError(jitter):
    ret_ad, _ = jitter.func_args_stdcall(0)
    jitter.func_ret_stdcall(ret_ad, winobjs.lastwin32error)
Severity: Major
Found in miasm/os_dep/win_api_x86_32.py and 5 other locations - About 30 mins to fix
miasm/os_dep/win_api_x86_32.py on lines 321..323
miasm/os_dep/win_api_x86_32.py on lines 331..333
miasm/os_dep/win_api_x86_32.py on lines 336..338
miasm/os_dep/win_api_x86_32.py on lines 374..376
miasm/os_dep/win_api_x86_32.py on lines 457..459

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 6 locations. Consider refactoring.
Open

def kernel32_GetCurrentProcess(jitter):
    ret_ad, _ = jitter.func_args_stdcall(0)
    jitter.func_ret_stdcall(ret_ad, winobjs.handle_curprocess)
Severity: Major
Found in miasm/os_dep/win_api_x86_32.py and 5 other locations - About 30 mins to fix
miasm/os_dep/win_api_x86_32.py on lines 321..323
miasm/os_dep/win_api_x86_32.py on lines 336..338
miasm/os_dep/win_api_x86_32.py on lines 374..376
miasm/os_dep/win_api_x86_32.py on lines 457..459
miasm/os_dep/win_api_x86_32.py on lines 1002..1004

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 6 locations. Consider refactoring.
Open

def kernel32_GetCurrentProcessId(jitter):
    ret_ad, _ = jitter.func_args_stdcall(0)
    jitter.func_ret_stdcall(ret_ad, winobjs.dw_pid_cur)
Severity: Major
Found in miasm/os_dep/win_api_x86_32.py and 5 other locations - About 30 mins to fix
miasm/os_dep/win_api_x86_32.py on lines 321..323
miasm/os_dep/win_api_x86_32.py on lines 331..333
miasm/os_dep/win_api_x86_32.py on lines 374..376
miasm/os_dep/win_api_x86_32.py on lines 457..459
miasm/os_dep/win_api_x86_32.py on lines 1002..1004

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 6 locations. Consider refactoring.
Open

def kernel32_GetVersion(jitter):
    ret_ad, _ = jitter.func_args_stdcall(0)
    jitter.func_ret_stdcall(ret_ad, winobjs.getversion)
Severity: Major
Found in miasm/os_dep/win_api_x86_32.py and 5 other locations - About 30 mins to fix
miasm/os_dep/win_api_x86_32.py on lines 321..323
miasm/os_dep/win_api_x86_32.py on lines 331..333
miasm/os_dep/win_api_x86_32.py on lines 336..338
miasm/os_dep/win_api_x86_32.py on lines 457..459
miasm/os_dep/win_api_x86_32.py on lines 1002..1004

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 4 locations. Consider refactoring.
Open

mips32op("ctc1",    [cpu.bs('010001'), cpu.bs('00110'), rt, fs,
                     cpu.bs('00000000000')])
Severity: Major
Found in miasm/arch/mips32/arch.py and 3 other locations - About 30 mins to fix
miasm/arch/mips32/arch.py on lines 690..691
miasm/arch/mips32/arch.py on lines 748..749
miasm/arch/mips32/arch.py on lines 751..752

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Identical blocks of code found in 2 locations. Consider refactoring.
Open

    e.append(m2_expr.ExprAssign(meip, ir.ExprMem(
Severity: Minor
Found in miasm/arch/x86/sem.py and 1 other location - About 30 mins to fix
miasm/arch/x86/sem.py on lines 1496..1496

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 4 locations. Consider refactoring.
Open

    e.append(m2_expr.ExprAssign(float_c2,
                             m2_expr.ExprOp('fcom_c2', dst,
                                            src.zeroExtend(dst.size))))
Severity: Major
Found in miasm/arch/x86/sem.py and 3 other locations - About 30 mins to fix
miasm/arch/x86/sem.py on lines 2258..2260
miasm/arch/x86/sem.py on lines 2261..2263
miasm/arch/x86/sem.py on lines 2267..2269

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Identical blocks of code found in 2 locations. Consider refactoring.
Open

    if not (expr.op.startswith("zeroExt") or expr.op.startswith("signExt")):
        return expr
Severity: Minor
Found in miasm/expression/simplifications_common.py and 1 other location - About 30 mins to fix
miasm/expression/simplifications_common.py on lines 1430..1431

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Similar blocks of code found in 3 locations. Consider refactoring.
Open

        name = struct.unpack('I', raw[off:off + 4])[0]
Severity: Minor
Found in miasm/loader/pe.py and 2 other locations - About 30 mins to fix
miasm/loader/pe.py on lines 1133..1133
miasm/loader/pe.py on lines 1562..1562

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Identical blocks of code found in 2 locations. Consider refactoring.
Open

            elif arg.op == 'LSL' and int(arg.args[1]) == 0:
Severity: Minor
Found in miasm/arch/aarch64/arch.py and 1 other location - About 30 mins to fix
miasm/arch/aarch64/arch.py on lines 425..425

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Identical blocks of code found in 2 locations. Consider refactoring.
Open

    if not (expr.op.startswith("zeroExt") or expr.op.startswith("signExt")):
        return expr
Severity: Minor
Found in miasm/expression/simplifications_common.py and 1 other location - About 30 mins to fix
miasm/expression/simplifications_common.py on lines 1448..1449

Duplicated Code

Duplicated code can lead to software that is hard to understand and difficult to change. The Don't Repeat Yourself (DRY) principle states:

Every piece of knowledge must have a single, unambiguous, authoritative representation within a system.

When you violate DRY, bugs and maintenance problems are sure to follow. Duplicated code has a tendency to both continue to replicate and also to diverge (leaving bugs as two similar implementations differ in subtle ways).

Tuning

This issue has a mass of 32.

We set useful threshold defaults for the languages we support but you may want to adjust these settings based on your project guidelines.

The threshold configuration represents the minimum mass a code block must have to be analyzed for duplication. The lower the threshold, the more fine-grained the comparison.

If the engine is too easily reporting duplication, try raising the threshold. If you suspect that the engine isn't catching enough duplication, try lowering the threshold. The best setting tends to differ from language to language.

See codeclimate-duplication's documentation for more information about tuning the mass threshold in your .codeclimate.yml.

Refactorings

Further Reading

Severity
Category
Status
Source
Language